SYMBOL INDEX (105 symbols across 17 files)

FILE: char-rnn-classification/data.py
  function findFiles (line 9) | def findFiles(path): return glob.glob(path)
  function unicodeToAscii (line 12) | def unicodeToAscii(s):
  function readLines (line 20) | def readLines(filename):
  function letterToIndex (line 36) | def letterToIndex(letter):
  function lineToTensor (line 41) | def lineToTensor(line):

FILE: char-rnn-classification/model.py
  class RNN (line 5) | class RNN(nn.Module):
    method __init__ (line 6) | def __init__(self, input_size, hidden_size, output_size):
    method forward (line 15) | def forward(self, input, hidden):
    method initHidden (line 22) | def initHidden(self):

FILE: char-rnn-classification/predict.py
  function evaluate (line 8) | def evaluate(line_tensor):
  function predict (line 16) | def predict(line, n_predictions=3):

FILE: char-rnn-classification/server.py
  function index (line 5) | def index(input_line):

FILE: char-rnn-classification/train.py
  function categoryFromOutput (line 14) | def categoryFromOutput(output):
  function randomChoice (line 19) | def randomChoice(l):
  function randomTrainingPair (line 22) | def randomTrainingPair():
  function train (line 33) | def train(category_tensor, line_tensor):
  function timeSince (line 51) | def timeSince(since):

FILE: char-rnn-generation/generate.py
  function generate (line 8) | def generate(decoder, prime_str='A', predict_len=100, temperature=0.8):

FILE: char-rnn-generation/helpers.py
  function read_file (line 16) | def read_file(filename):
  function char_tensor (line 22) | def char_tensor(string):
  function time_since (line 30) | def time_since(since):

FILE: char-rnn-generation/model.py
  class RNN (line 7) | class RNN(nn.Module):
    method __init__ (line 8) | def __init__(self, input_size, hidden_size, output_size, n_layers=1):
    method forward (line 19) | def forward(self, input, hidden):
    method init_hidden (line 25) | def init_hidden(self):

FILE: char-rnn-generation/train.py
  function random_training_set (line 26) | def random_training_set(chunk_len):
  function train (line 42) | def train(inp, target):
  function save (line 56) | def save():

FILE: conditional-char-rnn/data.py
  function unicode_to_ascii (line 20) | def unicode_to_ascii(s):
  function read_lines (line 27) | def read_lines(filename):
  function random_training_pair (line 43) | def random_training_pair():
  function make_category_input (line 48) | def make_category_input(category):
  function make_chars_input (line 54) | def make_chars_input(chars):
  function make_target (line 62) | def make_target(line):
  function random_training_set (line 68) | def random_training_set():

FILE: conditional-char-rnn/generate.py
  function generate_one (line 26) | def generate_one(category, start_char='A', temperature=0.5):
  function generate (line 50) | def generate(category, start_chars='ABC'):

FILE: conditional-char-rnn/model.py
  class RNN (line 7) | class RNN(nn.Module):
    method __init__ (line 8) | def __init__(self, category_size, input_size, hidden_size, output_size):
    method forward (line 20) | def forward(self, category, input, hidden):
    method init_hidden (line 28) | def init_hidden(self):

FILE: conditional-char-rnn/train.py
  function train (line 19) | def train(category_tensor, input_line_tensor, target_line_tensor):
  function time_since (line 33) | def time_since(t):
  function save (line 54) | def save():

FILE: reinforce-gridworld/helpers.py
  function interpolate (line 1) | def interpolate(i, v_from, v_to, over):
  class SlidingAverage (line 4) | class SlidingAverage:
    method __init__ (line 5) | def __init__(self, name, steps=100):
    method add (line 12) | def add(self, n):
    method value (line 21) | def value(self):
    method __str__ (line 25) | def __str__(self):
    method __gt__ (line 28) | def __gt__(self, value): return self.value > value
    method __lt__ (line 29) | def __lt__(self, value): return self.value < value

FILE: reinforce-gridworld/reinforce-gridworld.py
  class Grid (line 55) | class Grid():
    method __init__ (line 56) | def __init__(self, grid_size=8, n_plants=15):
    method reset (line 60) | def reset(self):
    method visible (line 84) | def visible(self, pos):
  class Agent (line 93) | class Agent:
    method reset (line 94) | def reset(self):
    method act (line 97) | def act(self, action):
  class Environment (line 109) | class Environment:
    method __init__ (line 110) | def __init__(self):
    method reset (line 114) | def reset(self):
    method record_step (line 127) | def record_step(self):
    method visible_state (line 135) | def visible_state(self):
    method step (line 144) | def step(self, action):
  class Policy (line 174) | class Policy(nn.Module):
    method __init__ (line 175) | def __init__(self, hidden_size):
    method forward (line 184) | def forward(self, x):
  function select_action (line 197) | def select_action(e, state):
  function run_episode (line 210) | def run_episode(e):
  function finish_episode (line 230) | def finish_episode(e, actions, values, rewards):

FILE: seq2seq-translation/masked_cross_entropy.py
  function sequence_mask (line 5) | def sequence_mask(sequence_length, max_len=None):
  function masked_cross_entropy (line 19) | def masked_cross_entropy(logits, target, length):

FILE: seq2seq-translation/seq2seq-translation-batched.py
  class Lang (line 76) | class Lang:
    method __init__ (line 77) | def __init__(self, name):
    method index_words (line 84) | def index_words(self, sentence):
    method index_word (line 88) | def index_word(self, word):
    method trim (line 97) | def trim(self, min_count=3):
  function unicode_to_ascii (line 117) | def unicode_to_ascii(s):
  function normalize_string (line 124) | def normalize_string(s):
  function read_langs (line 130) | def read_langs(lang1, lang2, reverse=False):
  function filter_pair (line 159) | def filter_pair(p):
  function filter_pairs (line 163) | def filter_pairs(pairs):
  function prepare_data (line 166) | def prepare_data(lang1_name, lang2_name, reverse=False):
  function indexes_from_sentence (line 209) | def indexes_from_sentence(lang, sentence):
  function pad_seq (line 212) | def pad_seq(seq, max_length):
  function random_batch (line 216) | def random_batch(batch_size=3):
  class EncoderRNN (line 248) | class EncoderRNN(nn.Module):
    method __init__ (line 249) | def __init__(self, input_size, hidden_size, n_layers=1, dropout=0.1):
    method forward (line 260) | def forward(self, input_seqs, input_lengths, hidden=None):
  class Attn (line 267) | class Attn(nn.Module):
    method __init__ (line 268) | def __init__(self, method, hidden_size):
    method forward (line 281) | def forward(self, hidden, encoder_outputs):
    method score (line 305) | def score(self, hidden, encoder_output):
  class LuongAttnDecoderRNN (line 337) | class LuongAttnDecoderRNN(nn.Module):
    method __init__ (line 338) | def __init__(self, attn_model, hidden_size, output_size, n_layers=1, d...
    method forward (line 359) | def forward(self, input_seq, last_context, last_hidden, encoder_outputs):
  function train (line 510) | def train(input_batches, input_lengths, target_batches, target_lengths, ...
  function as_minutes (line 609) | def as_minutes(s):
  function time_since (line 614) | def time_since(since, percent):
  function evaluate (line 621) | def evaluate(input_seq, max_length=MAX_LENGTH):
  function evaluate_randomly (line 667) | def evaluate_randomly():
  function show_plot_visdom (line 679) | def show_plot_visdom():
  function show_attention (line 686) | def show_attention(input_sentence, output_words, attentions):
  function evaluate_and_show_attention (line 705) | def evaluate_and_show_attention(input_sentence):