SYMBOL INDEX (153 symbols across 14 files)

FILE: cli.py
  function parse_args (line 23) | def parse_args():
  function prepro (line 123) | def prepro(args):
  function train (line 176) | def train(args):
  function evaluate (line 202) | def evaluate(args):
  function predict (line 232) | def predict(args):
  function run (line 256) | def run():

FILE: dataloader.py
  function word_tokenize (line 10) | def word_tokenize(sent):
  class DataLoader (line 21) | class DataLoader(object):
    method __init__ (line 25) | def __init__(self, max_p_num, max_p_len, max_q_len, max_char_len,
    method _load_dataset (line 51) | def _load_dataset(self, data_path, train=False):
    method _one_mini_batch (line 124) | def _one_mini_batch(self, data, indices, pad_id, pad_char_id):
    method _dynamic_padding (line 176) | def _dynamic_padding(self, batch_data, pad_id, pad_char_id):
    method word_iter (line 212) | def word_iter(self, set_name=None):
    method convert_to_ids (line 239) | def convert_to_ids(self, vocab):
    method next_batch (line 255) | def next_batch(self, set_name, batch_size, pad_id, pad_char_id, shuffl...

FILE: layers.py
  function shape_list (line 38) | def shape_list(inputs):
  function position_embedding (line 55) | def position_embedding(inputs, position_dim):
  function glu (line 73) | def glu(x):
  function noam_norm (line 78) | def noam_norm(x, epsilon=1.0, scope=None, reuse=None):
  function layer_norm_compute_python (line 85) | def layer_norm_compute_python(x, epsilon, scale, bias):
  function layer_norm (line 92) | def layer_norm(x, filters=None, epsilon=1e-6, scope=None, reuse=None):
  function highway (line 107) | def highway(x, size = None, activation = tf.nn.relu,
  function layer_dropout (line 123) | def layer_dropout(inputs, residual, dropout):
  function residual_block (line 127) | def residual_block(inputs, num_blocks, num_conv_layers, kernel_size, mas...
  function conv_block (line 147) | def conv_block(inputs, num_conv_layers, kernel_size, num_filters,
  function self_attention_block (line 165) | def self_attention_block(inputs, num_filters, seq_len, mask = None, num_...
  function multihead_attention (line 187) | def multihead_attention(queries, units, num_heads,
  function conv (line 217) | def conv(inputs, output_size, bias = None, activation = None, kernel_siz...
  function mask_logits (line 247) | def mask_logits(inputs, mask, mask_value = -1e30):
  function depthwise_separable_convolution (line 252) | def depthwise_separable_convolution(inputs, kernel_size, num_filters,
  function split_last_dimension (line 281) | def split_last_dimension(x, n):
  function dot_product_attention (line 297) | def dot_product_attention(q,
  function combine_last_two_dimensions (line 336) | def combine_last_two_dimensions(x):
  function add_timing_signal_1d (line 350) | def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
  function get_timing_signal_1d (line 377) | def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timesc...
  function trilinear (line 414) | def trilinear(args,
  function flatten (line 428) | def flatten(tensor, keep):
  function reconstruct (line 436) | def reconstruct(tensor, ref, keep):
  function _linear (line 449) | def _linear(args,
  function total_params (line 510) | def total_params(variables):

FILE: model.py
  class Model (line 18) | class Model(object):
    method __init__ (line 19) | def __init__(self, vocab, config, demo=False):
    method _build_graph (line 59) | def _build_graph(self):
    method _setup_placeholders (line 78) | def _setup_placeholders(self):
    method _embed (line 107) | def _embed(self):
    method _encode (line 193) | def _encode(self):
    method _fuse (line 222) | def _fuse(self):
    method _decode (line 264) | def _decode(self):
    method _compute_loss (line 291) | def _compute_loss(self):
    method _create_train_op (line 341) | def _create_train_op(self):
    method _attention (line 371) | def _attention(self, output, name='attn', reuse=None):
    method _train_epoch (line 405) | def _train_epoch(self, train_batches, dropout):
    method _params (line 433) | def _params(self):
    method train (line 438) | def train(self, data, epochs, batch_size, save_dir, save_prefix,
    method evaluate (line 465) | def evaluate(self, eval_batches, result_dir=None, result_prefix=None, ...
    method find_best_answer (line 530) | def find_best_answer(self, sample, start_prob, end_prob, padded_p_len):
    method find_best_answer_for_passage (line 555) | def find_best_answer_for_passage(self, start_probs, end_probs, passage...
    method save (line 576) | def save(self, model_dir, model_prefix):
    method restore (line 583) | def restore(self, model_dir, model_prefix):

FILE: optimizer.py
  class DecoupledWeightDecayExtension (line 16) | class DecoupledWeightDecayExtension(object):
    method __init__ (line 43) | def __init__(self, weight_decay, **kwargs):
    method minimize (line 57) | def minimize(self, loss, global_step=None, var_list=None,
    method apply_gradients (line 93) | def apply_gradients(self, grads_and_vars, global_step=None, name=None,
    method _prepare (line 117) | def _prepare(self):
    method _decay_weights_op (line 126) | def _decay_weights_op(self, var):
    method _decay_weights_sparse_op (line 131) | def _decay_weights_sparse_op(self, var, indices, scatter_add):
    method _apply_dense (line 139) | def _apply_dense(self, grad, var):
    method _resource_apply_dense (line 143) | def _resource_apply_dense(self, grad, var):
    method _apply_sparse (line 148) | def _apply_sparse(self, grad, var):
    method _resource_scatter_add (line 155) | def _resource_scatter_add(self, x, i, v, _=None):
    method _resource_apply_sparse (line 162) | def _resource_apply_sparse(self, grad, var, indices):
  function extend_with_decoupled_weight_decay (line 170) | def extend_with_decoupled_weight_decay(base_optimizer):
  class MomentumWOptimizer (line 226) | class MomentumWOptimizer(DecoupledWeightDecayExtension,
    method __init__ (line 246) | def __init__(self, weight_decay, learning_rate, momentum,
  class AdamWOptimizer (line 276) | class AdamWOptimizer(DecoupledWeightDecayExtension, adam.AdamOptimizer):
    method __init__ (line 294) | def __init__(self, weight_decay, learning_rate=0.001, beta1=0.9, beta2...

FILE: utils/bleu_metric/bleu.py
  class Bleu (line 14) | class Bleu:
    method __init__ (line 15) | def __init__(self, n=4):
    method compute_score (line 21) | def compute_score(self, gts, res):
    method method (line 46) | def method(self):

FILE: utils/bleu_metric/bleu_scorer.py
  function precook (line 23) | def precook(s, n=4, out=False):
  function cook_refs (line 35) | def cook_refs(refs, eff=None, n=4): ## lhuang: oracle will call with "av...
  function cook_test (line 60) | def cook_test(test, reflen, refmaxcounts, eff=None, n=4):
  class BleuScorer (line 85) | class BleuScorer(object):
    method copy (line 92) | def copy(self):
    method __init__ (line 100) | def __init__(self, test=None, refs=None, n=4, special_reflen=None):
    method cook_append (line 109) | def cook_append(self, test, refs):
    method ratio (line 124) | def ratio(self, option=None):
    method score_ratio (line 128) | def score_ratio(self, option=None):
    method score_ratio_str (line 132) | def score_ratio_str(self, option=None):
    method reflen (line 135) | def reflen(self, option=None):
    method testlen (line 139) | def testlen(self, option=None):
    method retest (line 143) | def retest(self, new_test):
    method rescore (line 154) | def rescore(self, new_test):
    method size (line 159) | def size(self):
    method __iadd__ (line 163) | def __iadd__(self, other):
    method compatible (line 177) | def compatible(self, other):
    method single_reflen (line 180) | def single_reflen(self, option="average"):
    method _single_reflen (line 183) | def _single_reflen(self, reflens, option=None, testlen=None):
    method recompute_score (line 196) | def recompute_score(self, option=None, verbose=0):
    method compute_score (line 200) | def compute_score(self, option=None, verbose=0):

FILE: utils/dureader_eval.py
  function normalize (line 35) | def normalize(s):
  function data_check (line 54) | def data_check(obj, task):
  function read_file (line 80) | def read_file(file_name, task, is_ref=False):
  function compute_bleu_rouge (line 125) | def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):
  function local_prf (line 140) | def local_prf(pred_list, ref_list):
  function compute_prf (line 155) | def compute_prf(pred_dict, ref_dict):
  function prepare_prf (line 192) | def prepare_prf(pred_dict, ref_dict):
  function filter_dict (line 201) | def filter_dict(result_dict, key_tag):
  function get_metrics (line 212) | def get_metrics(pred_result, ref_result, task, source):
  function prepare_bleu (line 265) | def prepare_bleu(pred_result, ref_result, task):
  function get_main_result (line 302) | def get_main_result(qid, pred_result, ref_result):
  function get_entity_result (line 327) | def get_entity_result(qid, pred_result, ref_result):
  function get_desc_result (line 347) | def get_desc_result(qid, pred_result, ref_result):
  function get_yesno_result (line 367) | def get_yesno_result(qid, pred_result, ref_result):
  function get_all_result (line 424) | def get_all_result(qid, pred_result, ref_result):
  function format_metrics (line 444) | def format_metrics(metrics, task, err_msg):
  function main (line 512) | def main(args):

FILE: utils/get_vocab.py
  function get_vocab (line 29) | def get_vocab(files, vocab_file):

FILE: utils/marco_tokenize_data.py
  function _nltk_tokenize (line 6) | def _nltk_tokenize(sequence):
  function segment (line 18) | def segment(input_js):

FILE: utils/marcov1_to_dureader.py
  function trans (line 8) | def trans(input_js):

FILE: utils/preprocess.py
  function precision_recall_f1 (line 29) | def precision_recall_f1(prediction, ground_truth):
  function recall (line 58) | def recall(prediction, ground_truth):
  function f1_score (line 72) | def f1_score(prediction, ground_truth):
  function metric_max_over_ground_truths (line 86) | def metric_max_over_ground_truths(metric_fn, prediction, ground_truths):
  function find_best_question_match (line 105) | def find_best_question_match(doc, question, with_score=False):
  function find_fake_answer (line 142) | def find_fake_answer(sample):

FILE: utils/rouge_metric/rouge.py
  function my_lcs (line 13) | def my_lcs(string, sub):
  class Rouge (line 36) | class Rouge():
    method __init__ (line 41) | def __init__(self):
    method calc_score (line 45) | def calc_score(self, candidate, refs):
    method compute_score (line 77) | def compute_score(self, gts, res):
    method method (line 104) | def method(self):

FILE: vocab.py
  class Vocab (line 14) | class Vocab(object):
    method __init__ (line 15) | def __init__(self, filename=None, initial_tokens=None, lower=False):
    method load_from_file (line 45) | def load_from_file(self, file_path):
    method word_size (line 51) | def word_size(self):
    method char_size (line 54) | def char_size(self):
    method get_word_id (line 57) | def get_word_id(self, token):
    method get_char_id (line 61) | def get_char_id(self, token):
    method get_word_token (line 65) | def get_word_token(self, idx):
    method add_word (line 68) | def add_word(self, token, cnt=1):
    method add_char (line 83) | def add_char(self, token, cnt=1):
    method filter_words_by_cnt (line 98) | def filter_words_by_cnt(self, min_cnt):
    method filter_chars_by_cnt (line 109) | def filter_chars_by_cnt(self, min_cnt):
    method randomly_init_word_embeddings (line 119) | def randomly_init_word_embeddings(self, embed_dim):
    method randomly_init_char_embeddings (line 125) | def randomly_init_char_embeddings(self, embed_dim):
    method load_pretrained_word_embeddings (line 134) | def load_pretrained_word_embeddings(self, embedding_path):
    method load_pretrained_char_embeddings (line 159) | def load_pretrained_char_embeddings(self, embedding_path):
    method convert_word_to_ids (line 188) | def convert_word_to_ids(self, tokens):
    method convert_char_to_ids (line 192) | def convert_char_to_ids(self, tokens):
    method recover_from_word_ids (line 201) | def recover_from_word_ids(self, ids, stop_id=None):