SYMBOL INDEX (1333 symbols across 172 files)

FILE: Inference.py
  function infer_single_example (line 49) | def infer_single_example(story,actual_summary,tokenizer):
  function results (line 81) | def results():

FILE: main.py
  function _train_epoch (line 14) | def _train_epoch(sess, epoch, step, smry_writer):
  function _eval_epoch (line 61) | def _eval_epoch(sess, epoch, mode):

FILE: preprocess.py
  class InputExample (line 13) | class InputExample():
    method __init__ (line 16) | def __init__(self, guid, text_a, text_b=None):
  class InputFeatures (line 31) | class InputFeatures():
    method __init__ (line 34) | def __init__(self, src_input_ids,src_input_mask,src_segment_ids,tgt_in...
  class DataProcessor (line 43) | class DataProcessor(object):
    method get_train_examples (line 46) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 50) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 54) | def get_test_examples(self, data_dir):
    method get_labels (line 58) | def get_labels(self):
    method _read_tsv (line 63) | def _read_tsv(cls, input_file, quotechar=None):
    method _read_file (line 75) | def _read_file(cls, input_file, quotechar=None):
  class CNNDailymail (line 86) | class CNNDailymail(DataProcessor):
    method get_train_examples (line 89) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 95) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 101) | def get_test_examples(self, data_dir):
    method _create_examples (line 107) | def _create_examples(self, src_lines,tgt_lines,set_type):
  function file_based_convert_examples_to_features (line 124) | def file_based_convert_examples_to_features(
  function convert_single_example (line 162) | def convert_single_example(ex_index, example, max_seq_length_src,max_seq...
  function file_based_input_fn_builder (line 246) | def file_based_input_fn_builder(input_file, max_seq_length_src,max_seq_l...
  function get_dataset (line 321) | def get_dataset(processor,

FILE: texar_repo/bin/average_checkpoints.py
  function main (line 29) | def main():

FILE: texar_repo/bin/train.py
  function _process_config (line 107) | def _process_config():
  function _get_run_config (line 146) | def _get_run_config(config):
  function main (line 168) | def main(_):

FILE: texar_repo/bin/utils/make_vocab.py
  function main (line 64) | def main(_):

FILE: texar_repo/examples/bert/bert_classifier_main.py
  function main (line 70) | def main(_):

FILE: texar_repo/examples/bert/utils/data_utils.py
  class InputExample (line 28) | class InputExample():
    method __init__ (line 31) | def __init__(self, guid, text_a, text_b=None, label=None):
  class InputFeatures (line 48) | class InputFeatures():
    method __init__ (line 51) | def __init__(self, input_ids, input_mask, segment_ids, label_id):
  class DataProcessor (line 58) | class DataProcessor(object):
    method get_train_examples (line 61) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 65) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 69) | def get_test_examples(self, data_dir):
    method get_labels (line 73) | def get_labels(self):
    method _read_tsv (line 78) | def _read_tsv(cls, input_file, quotechar=None):
  class SSTProcessor (line 88) | class SSTProcessor(DataProcessor):
    method get_train_examples (line 91) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 96) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 101) | def get_test_examples(self, data_dir):
    method get_labels (line 106) | def get_labels(self):
    method _create_examples (line 110) | def _create_examples(self, lines, set_type):
  class XnliProcessor (line 137) | class XnliProcessor(DataProcessor):
    method __init__ (line 140) | def __init__(self):
    method get_train_examples (line 143) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 162) | def get_dev_examples(self, data_dir):
    method get_labels (line 180) | def get_labels(self):
  class MnliProcessor (line 184) | class MnliProcessor(DataProcessor):
    method get_train_examples (line 187) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 192) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 198) | def get_test_examples(self, data_dir):
    method get_labels (line 204) | def get_labels(self):
    method _create_examples (line 208) | def _create_examples(self, lines, set_type):
  class MrpcProcessor (line 226) | class MrpcProcessor(DataProcessor):
    method get_train_examples (line 229) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 235) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 241) | def get_test_examples(self, data_dir):
    method get_labels (line 247) | def get_labels(self):
    method _create_examples (line 251) | def _create_examples(self, lines, set_type):
  class ColaProcessor (line 268) | class ColaProcessor(DataProcessor):
    method get_train_examples (line 271) | def get_train_examples(self, data_dir):
    method get_dev_examples (line 277) | def get_dev_examples(self, data_dir):
    method get_test_examples (line 283) | def get_test_examples(self, data_dir):
    method get_labels (line 289) | def get_labels(self):
    method _create_examples (line 293) | def _create_examples(self, lines, set_type):
  function convert_single_example (line 312) | def convert_single_example(ex_index, example, label_list, max_seq_length,
  function file_based_convert_examples_to_features (line 408) | def file_based_convert_examples_to_features(
  function file_based_input_fn_builder (line 433) | def file_based_input_fn_builder(input_file, seq_length, is_training,
  function _truncate_seq_pair (line 501) | def _truncate_seq_pair(tokens_a, tokens_b, max_length):
  function get_dataset (line 518) | def get_dataset(processor,

FILE: texar_repo/examples/bert/utils/model_utils.py
  function transform_bert_to_texar_config (line 15) | def transform_bert_to_texar_config(input_json):
  function get_lr (line 76) | def get_lr(global_step, num_train_steps, num_warmup_steps, static_lr):
  function _get_assignment_map_from_checkpoint (line 108) | def _get_assignment_map_from_checkpoint(tvars, init_checkpoint):
  function init_bert_checkpoint (line 173) | def init_bert_checkpoint(init_checkpoint):
  function set_random_seed (line 181) | def set_random_seed(myseed):

FILE: texar_repo/examples/bert/utils/tokenization.py
  function convert_to_unicode (line 29) | def convert_to_unicode(text):
  function printable_text (line 33) | def printable_text(text):
  function load_vocab (line 37) | def load_vocab(vocab_file):
  function convert_by_vocab (line 52) | def convert_by_vocab(vocab, items):
  function convert_tokens_to_ids (line 60) | def convert_tokens_to_ids(vocab, tokens):
  function convert_ids_to_tokens (line 64) | def convert_ids_to_tokens(inv_vocab, ids):
  function whitespace_tokenize (line 68) | def whitespace_tokenize(text):
  class FullTokenizer (line 77) | class FullTokenizer(object):
    method __init__ (line 80) | def __init__(self, vocab_file, do_lower_case=True):
    method tokenize (line 86) | def tokenize(self, text):
    method convert_tokens_to_ids (line 94) | def convert_tokens_to_ids(self, tokens):
    method convert_ids_to_tokens (line 97) | def convert_ids_to_tokens(self, ids):
  class BasicTokenizer (line 101) | class BasicTokenizer(object):
    method __init__ (line 104) | def __init__(self, do_lower_case=True):
    method tokenize (line 112) | def tokenize(self, text):
    method _run_strip_accents (line 136) | def _run_strip_accents(self, text):
    method _run_split_on_punc (line 147) | def _run_split_on_punc(self, text):
    method _tokenize_chinese_chars (line 167) | def _tokenize_chinese_chars(self, text):
    method _is_chinese_char (line 180) | def _is_chinese_char(self, cp):
    method _clean_text (line 204) | def _clean_text(self, text):
  class WordpieceTokenizer (line 218) | class WordpieceTokenizer(object):
    method __init__ (line 221) | def __init__(self, vocab, unk_token="[UNK]", max_input_chars_per_word=...
    method tokenize (line 226) | def tokenize(self, text):
  function _is_whitespace (line 279) | def _is_whitespace(char):
  function _is_control (line 291) | def _is_control(char):
  function _is_punctuation (line 303) | def _is_punctuation(char):

FILE: texar_repo/examples/distributed_gpu/lm_ptb_distributed.py
  function _main (line 72) | def _main(_):

FILE: texar_repo/examples/distributed_gpu/ptb_reader.py
  function ptb_iterator (line 29) | def ptb_iterator(data, batch_size, num_steps, is_train=False):
  function prepare_data (line 61) | def prepare_data(data_path):

FILE: texar_repo/examples/hierarchical_dialog/hred.py
  function main (line 45) | def main():

FILE: texar_repo/examples/hierarchical_dialog/sw_loader.py
  class Dataset (line 31) | class Dataset(object):
    method __init__ (line 35) | def __init__(self, jsonl_path, mode=None):
    method __len__ (line 94) | def __len__(self):
    method __getitem__ (line 97) | def __getitem__(self, idx):
    method get (line 114) | def get(self, idx):
  function sw1c2r (line 122) | def sw1c2r(data_root):
  function generate_reference_for_test_dialog (line 133) | def generate_reference_for_test_dialog(dataset, data_root):
  function download_and_process (line 193) | def download_and_process(data_root):

FILE: texar_repo/examples/language_model_ptb/lm_ptb.py
  function _main (line 71) | def _main(_):

FILE: texar_repo/examples/language_model_ptb/ptb_reader.py
  function ptb_iterator (line 29) | def ptb_iterator(data, batch_size, num_steps):
  function prepare_data (line 47) | def prepare_data(data_path):

FILE: texar_repo/examples/memory_network_lm/lm_ptb_memnet.py
  function _main (line 62) | def _main(_):

FILE: texar_repo/examples/memory_network_lm/ptb_reader.py
  function ptb_iterator (line 29) | def ptb_iterator(data, batch_size, num_steps):
  function ptb_iterator_memnet (line 47) | def ptb_iterator_memnet(data, batch_size, memory_size):
  function prepare_data (line 66) | def prepare_data(data_path):

FILE: texar_repo/examples/rl_gym/pg_cartpole.py
  function _main (line 38) | def _main(_):

FILE: texar_repo/examples/sentence_classifier/clas_main.py
  function _main (line 40) | def _main(_):

FILE: texar_repo/examples/sentence_classifier/sst_data_preprocessor.py
  function clean_sst_text (line 39) | def clean_sst_text(text):
  function transform_raw_sst (line 46) | def transform_raw_sst(data_path, raw_fn, new_fn):
  function prepare_data (line 66) | def prepare_data(data_path):
  function _main (line 91) | def _main(_):

FILE: texar_repo/examples/seq2seq_attn/prepare_data.py
  function prepare_data (line 27) | def prepare_data():
  function main (line 47) | def main():

FILE: texar_repo/examples/seq2seq_attn/seq2seq_attn.py
  function build_model (line 37) | def build_model(batch, train_data):
  function main (line 83) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/baseline_seq2seq_attn_main.py
  function build_model (line 50) | def build_model(batch, train_data):
  function print_stdout_and_file (line 96) | def print_stdout_and_file(content, file):
  function main (line 101) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/interpolation_decoder.py
  class InterpolationDecoder (line 32) | class InterpolationDecoder(AttentionRNNDecoder):
    method __init__ (line 70) | def __init__(self,
    method initialize (line 83) | def initialize(self, name=None):
    method step (line 98) | def step(self, time, inputs, state, name=None):

FILE: texar_repo/examples/seq2seq_exposure_bias/interpolation_helper.py
  function calc_reward (line 32) | def calc_reward(refs, hypo, unk_id, metric):
  class InterpolationHelper (line 57) | class InterpolationHelper(SampleEmbeddingHelper):
    method __init__ (line 75) | def __init__(self,
    method sample (line 92) | def sample(self, time, outputs, state, name=None):
    method next_inputs (line 121) | def next_inputs(self, time, outputs, state, sample_ids, name=None):
    method _sample_by_reward (line 135) | def _sample_by_reward(self, time, state):

FILE: texar_repo/examples/seq2seq_exposure_bias/interpolation_main.py
  function build_model (line 71) | def build_model(batch, train_data, lambdas):
  function print_stdout_and_file (line 133) | def print_stdout_and_file(content, file):
  function main (line 138) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/raml_main.py
  function read_raml_sample_file (line 64) | def read_raml_sample_file():
  function raml_loss (line 86) | def raml_loss(batch, output, training_rewards):
  function build_model (line 96) | def build_model(batch, train_data, rewards):
  function print_stdout_and_file (line 142) | def print_stdout_and_file(content, file):
  function main (line 147) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/scheduled_sampling_main.py
  function inverse_sigmoid (line 60) | def inverse_sigmoid(i):
  function build_model (line 65) | def build_model(batch, train_data, self_sampling_proba):
  function print_stdout_and_file (line 120) | def print_stdout_and_file(content, file):
  function main (line 125) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/utils/prepare_data.py
  function prepare_data (line 28) | def prepare_data():
  function main (line 49) | def main():

FILE: texar_repo/examples/seq2seq_exposure_bias/utils/raml_samples_generation/process_samples.py
  function is_valid_sample (line 16) | def is_valid_sample(sent):
  function sample_from_model (line 21) | def sample_from_model(args):
  function get_new_ngram (line 86) | def get_new_ngram(ngram, n, vocab):
  function sample_ngram (line 97) | def sample_ngram(args):
  function sample_ngram_adapt (line 167) | def sample_ngram_adapt(args):
  function sample_from_hamming_distance_payoff_distribution (line 229) | def sample_from_hamming_distance_payoff_distribution(args):
  function generate_hamming_distance_payoff_distribution (line 270) | def generate_hamming_distance_payoff_distribution(max_sent_len, vocab_si...

FILE: texar_repo/examples/seq2seq_exposure_bias/utils/raml_samples_generation/util.py
  function read_corpus (line 4) | def read_corpus(file_path, source):
  function batch_slice (line 16) | def batch_slice(data, batch_size, sort=True):
  function data_iter (line 31) | def data_iter(data, batch_size, shuffle=True):

FILE: texar_repo/examples/seq2seq_exposure_bias/utils/raml_samples_generation/vocab.py
  class VocabEntry (line 11) | class VocabEntry(object):
    method __init__ (line 12) | def __init__(self):
    method __getitem__ (line 22) | def __getitem__(self, word):
    method __contains__ (line 25) | def __contains__(self, word):
    method __setitem__ (line 28) | def __setitem__(self, key, value):
    method __len__ (line 31) | def __len__(self):
    method __repr__ (line 34) | def __repr__(self):
    method id2word (line 37) | def id2word(self, wid):
    method add (line 40) | def add(self, word):
    method from_corpus (line 49) | def from_corpus(corpus, size, remove_singleton=True):
  class Vocab (line 67) | class Vocab(object):
    method __init__ (line 68) | def __init__(self, src_sents, tgt_sents, src_vocab_size, tgt_vocab_siz...
    method __repr__ (line 77) | def __repr__(self):

FILE: texar_repo/examples/seq2seq_rl/prepare_data.py
  function prepare_data (line 27) | def prepare_data():
  function main (line 47) | def main():

FILE: texar_repo/examples/seq2seq_rl/seq2seq_attn_pg.py
  function build_model (line 49) | def build_model(batch, train_data):
  function main (line 91) | def main():

FILE: texar_repo/examples/seqgan/data_utils.py
  function prepare_data (line 36) | def prepare_data(args, config, train_path):

FILE: texar_repo/examples/seqgan/seqgan_train.py
  function _main (line 40) | def _main(_):

FILE: texar_repo/examples/sequence_tagging/conll_reader.py
  function create_vocabs (line 38) | def create_vocabs(train_path, dev_path, test_path, normalize_digits=True...
  function read_data (line 92) | def read_data(source_path, word_vocab, char_vocab, ner_vocab, normalize_...
  function iterate_batch (line 109) | def iterate_batch(data, batch_size, shuffle=False):
  function load_glove (line 144) | def load_glove(filename, emb_dim, normalize_digits=True):
  function construct_init_word_vecs (line 175) | def construct_init_word_vecs(vocab, word_vecs, glove_dict):
  class CoNLLReader (line 188) | class CoNLLReader(object):
    method __init__ (line 189) | def __init__(self, file_path, word_vocab, char_vocab, ner_vocab):
    method close (line 195) | def close(self):
    method getNext (line 198) | def getNext(self, normalize_digits=True):
  class NERInstance (line 247) | class NERInstance(object):
    method __init__ (line 248) | def __init__(self, sentence, ner_tags, ner_ids):
    method length (line 253) | def length(self):
  class Sentence (line 257) | class Sentence(object):
    method __init__ (line 258) | def __init__(self, words, word_ids, char_seqs, char_id_seqs):
    method length (line 264) | def length(self):

FILE: texar_repo/examples/sequence_tagging/conll_writer.py
  class CoNLLWriter (line 4) | class CoNLLWriter(object):
    method __init__ (line 5) | def __init__(self, i2w, i2n):
    method start (line 10) | def start(self, file_path):
    method close (line 13) | def close(self):
    method write (line 16) | def write(self, word, predictions, targets, lengths):

FILE: texar_repo/examples/sequence_tagging/ner.py
  function _train_epoch (line 132) | def _train_epoch(sess, epoch):
  function _eval (line 164) | def _eval(sess, epoch, data_tag):

FILE: texar_repo/examples/sequence_tagging/scores.py
  function scores (line 4) | def scores(path):

FILE: texar_repo/examples/text_style_transfer/ctrl_gen_model.py
  class CtrlGenModel (line 32) | class CtrlGenModel(object):
    method __init__ (line 36) | def __init__(self, inputs, vocab, gamma, lambda_g, hparams=None):
    method _build_model (line 40) | def _build_model(self, inputs, vocab, gamma, lambda_g):

FILE: texar_repo/examples/text_style_transfer/main.py
  function _main (line 51) | def _main(_):

FILE: texar_repo/examples/text_style_transfer/prepare_data.py
  function prepare_data (line 20) | def prepare_data():
  function main (line 30) | def main():

FILE: texar_repo/examples/torchtext/batchfirst_bptt.py
  class BatchFirstBPTTIterator (line 18) | class BatchFirstBPTTIterator(BPTTIterator):
    method __len__ (line 47) | def __len__(self):
    method __iter__ (line 51) | def __iter__(self):

FILE: texar_repo/examples/torchtext/lm_torchtext.py
  function _main (line 48) | def _main(_):

FILE: texar_repo/examples/transformer/bleu_tool.py
  function _get_ngrams (line 54) | def _get_ngrams(segment, max_order):
  function compute_bleu (line 74) | def compute_bleu(reference_corpus,
  class UnicodeRegex (line 142) | class UnicodeRegex(object):
    method __init__ (line 145) | def __init__(self):
    method property_chars (line 151) | def property_chars(self, prefix):
  function bleu_tokenize (line 160) | def bleu_tokenize(string):
  function bleu_wrapper (line 190) | def bleu_wrapper(ref_filename, hyp_filename, case_sensitive=False):

FILE: texar_repo/examples/transformer/transformer_main.py
  function main (line 52) | def main():

FILE: texar_repo/examples/transformer/utils/data_utils.py
  function load_data_numpy (line 23) | def load_data_numpy(input_dir, prefix):
  function seq2seq_pad_concat_convert (line 33) | def seq2seq_pad_concat_convert(xy_batch, eos_id=2, bos_id=1):
  function source_pad_concat_convert (line 73) | def source_pad_concat_convert(x_seqs, eos_id=2, bos_id=1):
  function _concat_examples (line 85) | def _concat_examples(arrays, padding=0):
  function write_words (line 105) | def write_words(words_list, filename):

FILE: texar_repo/examples/transformer/utils/preprocess.py
  function split_sentence (line 36) | def split_sentence(s, tok=False):
  function open_file (line 52) | def open_file(path):
  function read_file (line 56) | def read_file(path, tok=False):
  function count_words (line 64) | def count_words(path, max_vocab_size=40000, tok=False):
  function make_array (line 74) | def make_array(word_id, words):
  function make_dataset (line 79) | def make_dataset(path, w2id, tok=False):
  function get_preprocess_args (line 94) | def get_preprocess_args():

FILE: texar_repo/examples/transformer/utils/utils.py
  function set_random_seed (line 28) | def set_random_seed(myseed):
  function batch_size_fn (line 33) | def batch_size_fn(new, count, size_so_far):
  function get_lr (line 41) | def get_lr(fstep, opt_config):
  function get_logger (line 50) | def get_logger(log_path):
  function list_strip_eos (line 65) | def list_strip_eos(list_, eos_token):

FILE: texar_repo/examples/vae_text/prepare_data.py
  function prepare_data (line 22) | def prepare_data(data_name):

FILE: texar_repo/examples/vae_text/vae_train.py
  function kl_dvg (line 58) | def kl_dvg(means, logvars):
  function _main (line 68) | def _main(_):

FILE: texar_repo/texar/agents/ac_agent.py
  class ActorCriticAgent (line 34) | class ActorCriticAgent(EpisodicAgentBase):
    method __init__ (line 77) | def __init__(self,
    method default_hparams (line 122) | def default_hparams():
    method _reset (line 175) | def _reset(self):
    method _observe (line 179) | def _observe(self, reward, terminal, train_policy, feed_dict):
    method _train_actor (line 186) | def _train_actor(self, observ, action, feed_dict):
    method get_action (line 200) | def get_action(self, observ, feed_dict=None):
    method sess (line 209) | def sess(self):
    method sess (line 215) | def sess(self, session):

FILE: texar_repo/texar/agents/agent_base.py
  class AgentBase (line 30) | class AgentBase(object):
    method __init__ (line 37) | def __init__(self, hparams=None):
    method default_hparams (line 45) | def default_hparams():
    method variable_scope (line 55) | def variable_scope(self):
    method name (line 61) | def name(self):
    method hparams (line 67) | def hparams(self):

FILE: texar_repo/texar/agents/agent_gym_utils.py
  function convert_gym_space (line 28) | def convert_gym_space(spc):
  function get_gym_env_config (line 45) | def get_gym_env_config(env):

FILE: texar_repo/texar/agents/agent_utils.py
  class Space (line 37) | class Space(object):
    method __init__ (line 71) | def __init__(self, shape=None, low=None, high=None, dtype=None):
    method contains (line 104) | def contains(self, x):
    method shape (line 118) | def shape(self):
    method low (line 124) | def low(self):
    method high (line 130) | def high(self):
    method dtype (line 136) | def dtype(self):
  class EnvConfig (line 141) | class EnvConfig(object):
    method __init__ (line 153) | def __init__(self,

FILE: texar_repo/texar/agents/agent_utils_test.py
  class SpaceTest (line 19) | class SpaceTest(tf.test.TestCase):
    method _test_space (line 23) | def _test_space(self, s, shape, low, high, dtype):
    method test_space (line 29) | def test_space(self):

FILE: texar_repo/texar/agents/dqn_agent.py
  class DQNAgent (line 38) | class DQNAgent(EpisodicAgentBase):
    method __init__ (line 87) | def __init__(self,
    method default_hparams (line 151) | def default_hparams():
    method _build_graph (line 260) | def _build_graph(self):
    method _get_qnet_outputs (line 288) | def _get_qnet_outputs(self, state_inputs):
    method _get_target_outputs (line 291) | def _get_target_outputs(self, state_inputs):
    method _get_td_error (line 294) | def _get_td_error(self, qnet_qvalues, actions, y):
    method _get_train_op (line 297) | def _get_train_op(self):
    method _get_copy_update_op (line 304) | def _get_copy_update_op(self):
    method _get_tau_update_op (line 311) | def _get_tau_update_op(self):
    method _observe (line 321) | def _observe(self, reward, terminal, train_policy, feed_dict):
    method _train_qnet (line 336) | def _train_qnet(self, feed_dict):
    method _update_target (line 366) | def _update_target(self, feed_dict):
    method _qvalues_from_qnet (line 372) | def _qvalues_from_qnet(self, observ):
    method _qvalues_from_target (line 378) | def _qvalues_from_target(self, observ):
    method _update_observ_action (line 384) | def _update_observ_action(self, observ, action):
    method _get_action (line 390) | def _get_action(self, observ, feed_dict=None):
    method _reset (line 402) | def _reset(self):
    method sess (line 407) | def sess(self):
    method sess (line 413) | def sess(self, session):

FILE: texar_repo/texar/agents/episodic_agent_base.py
  class EpisodicAgentBase (line 27) | class EpisodicAgentBase(AgentBase):
    method __init__ (line 66) | def __init__(self, env_config, hparams=None):
    method default_hparams (line 79) | def default_hparams():
    method reset (line 92) | def reset(self):
    method _reset (line 97) | def _reset(self):
    method observe (line 100) | def observe(self, reward, terminal, train_policy=True, feed_dict=None):
    method _observe (line 113) | def _observe(self, reward, terminal, train_policy, feed_dict):
    method get_action (line 116) | def get_action(self, observ, feed_dict=None):
    method _get_action (line 127) | def _get_action(self, observ, feed_dict):
    method env_config (line 131) | def env_config(self):

FILE: texar_repo/texar/agents/pg_agent.py
  class PGAgent (line 31) | class PGAgent(EpisodicAgentBase):
    method __init__ (line 80) | def __init__(self,
    method _build_graph (line 113) | def _build_graph(self):
    method _get_policy_outputs (line 134) | def _get_policy_outputs(self):
    method _get_pg_loss (line 139) | def _get_pg_loss(self):
    method _get_train_op (line 154) | def _get_train_op(self):
    method default_hparams (line 163) | def default_hparams():
    method _reset (line 216) | def _reset(self):
    method _get_action (line 221) | def _get_action(self, observ, feed_dict):
    method _observe (line 238) | def _observe(self, reward, terminal, train_policy, feed_dict):
    method _train_policy (line 244) | def _train_policy(self, feed_dict=None):
    method sess (line 265) | def sess(self):
    method sess (line 271) | def sess(self, session):
    method policy (line 275) | def policy(self):

FILE: texar_repo/texar/agents/seq_agent_base.py
  class SeqAgentBase (line 25) | class SeqAgentBase(AgentBase):
    method __init__ (line 32) | def __init__(self, hparams=None):
    method default_hparams (line 37) | def default_hparams():

FILE: texar_repo/texar/agents/seq_pg_agent.py
  class SeqPGAgent (line 34) | class SeqPGAgent(SeqAgentBase):
    method __init__ (line 86) | def __init__(self,
    method _build_graph (line 117) | def _build_graph(self):
    method _get_pg_loss (line 126) | def _get_pg_loss(self):
    method _get_entropy (line 146) | def _get_entropy(self):
    method _get_train_op (line 157) | def _get_train_op(self):
    method default_hparams (line 166) | def default_hparams():
    method _get_partial_run_feeds (line 230) | def _get_partial_run_feeds(self, feeds=None):
    method _setup_partial_run (line 236) | def _setup_partial_run(self, fetches=None, feeds=None):
    method _check_extra_fetches (line 251) | def _check_extra_fetches(self, extra_fetches):
    method get_samples (line 273) | def get_samples(self, extra_fetches=None, feed_dict=None):
    method observe (line 335) | def observe(self, reward, train_policy=True, compute_loss=True):
    method _get_qvalues (line 362) | def _get_qvalues(self):
    method _evaluate_pg_loss (line 370) | def _evaluate_pg_loss(self):
    method _train_policy (line 387) | def _train_policy(self):
    method sess (line 407) | def sess(self):
    method sess (line 413) | def sess(self, sess):
    method pg_loss (line 417) | def pg_loss(self):
    method sequence_length (line 423) | def sequence_length(self):
    method samples (line 429) | def samples(self):
    method logits (line 435) | def logits(self):

FILE: texar_repo/texar/agents/seq_pg_agent_test.py
  class SeqPGAgentTest (line 29) | class SeqPGAgentTest(tf.test.TestCase):
    method setUp (line 33) | def setUp(self):
    method test_seq_pg_agent (line 45) | def test_seq_pg_agent(self):

FILE: texar_repo/texar/context.py
  function global_mode (line 34) | def global_mode():
  function global_mode_train (line 66) | def global_mode_train():
  function global_mode_eval (line 84) | def global_mode_eval():
  function global_mode_predict (line 90) | def global_mode_predict():
  function valid_modes (line 96) | def valid_modes():

FILE: texar_repo/texar/context_test.py
  class ContextTest (line 18) | class ContextTest(tf.test.TestCase):
    method test_global_mode (line 22) | def test_global_mode(self):

FILE: texar_repo/texar/core/explorations.py
  class ExplorationBase (line 31) | class ExplorationBase(object):
    method __init__ (line 39) | def __init__(self, hparams=None):
    method default_hparams (line 43) | def default_hparams():
    method get_epsilon (line 56) | def get_epsilon(self, timestep):
    method hparams (line 68) | def hparams(self):
  class EpsilonLinearDecayExploration (line 74) | class EpsilonLinearDecayExploration(ExplorationBase):
    method __init__ (line 82) | def __init__(self, hparams=None):
    method default_hparams (line 86) | def default_hparams():
    method get_epsilon (line 112) | def get_epsilon(self, timestep):

FILE: texar_repo/texar/core/layers.py
  function default_rnn_cell_hparams (line 72) | def default_rnn_cell_hparams():
  function get_rnn_cell (line 189) | def get_rnn_cell(hparams=None, mode=None):
  function get_rnn_cell_trainable_variables (line 279) | def get_rnn_cell_trainable_variables(cell):
  function default_regularizer_hparams (line 298) | def default_regularizer_hparams():
  function get_regularizer (line 323) | def get_regularizer(hparams=None):
  function get_initializer (line 366) | def get_initializer(hparams=None):
  function get_activation_fn (line 421) | def get_activation_fn(fn_name="identity", kwargs=None):
  function get_constraint_fn (line 466) | def get_constraint_fn(fn_name="NonNeg"):
  function get_layer (line 503) | def get_layer(hparams):
  function _compute_concat_output_shape (line 603) | def _compute_concat_output_shape(input_shape, axis):
  class _ReducePooling1D (line 628) | class _ReducePooling1D(tf.layers.Layer):
    method __init__ (line 636) | def __init__(self, reduce_function, data_format='channels_last',
    method compute_output_shape (line 645) | def compute_output_shape(self, input_shape):
    method call (line 652) | def call(self, inputs):
  class MaxReducePooling1D (line 658) | class MaxReducePooling1D(_ReducePooling1D):
    method __init__ (line 664) | def __init__(self, data_format='channels_last', name=None, **kwargs):
  class AverageReducePooling1D (line 668) | class AverageReducePooling1D(_ReducePooling1D):
    method __init__ (line 674) | def __init__(self, data_format='channels_last', name=None, **kwargs):
  function get_pooling_layer_hparams (line 685) | def get_pooling_layer_hparams(hparams):
  class MergeLayer (line 708) | class MergeLayer(tf.layers.Layer):
    method __init__ (line 753) | def __init__(self,
    method compute_output_shape (line 780) | def compute_output_shape(self, input_shape):
    method _collect_weights (line 814) | def _collect_weights(self):
    method call (line 829) | def call(self, inputs):
    method layers (line 884) | def layers(self):
  class SequentialLayer (line 890) | class SequentialLayer(tf.layers.Layer):
    method __init__ (line 901) | def __init__(self,
    method compute_output_shape (line 921) | def compute_output_shape(self, input_shape):
    method _collect_weights (line 928) | def _collect_weights(self):
    method call (line 941) | def call(self, inputs, mode=None): # pylint: disable=arguments-differ
    method layers (line 960) | def layers(self):
  function _common_default_conv_dense_kwargs (line 966) | def _common_default_conv_dense_kwargs():
  function default_conv1d_kwargs (line 990) | def default_conv1d_kwargs():
  function default_conv2d_kwargs (line 1045) | def default_conv2d_kwargs():
  function default_conv3d_kwargs (line 1049) | def default_conv3d_kwargs():
  function default_conv2d_transpose_kwargs (line 1053) | def default_conv2d_transpose_kwargs():
  function default_conv3d_transpose_kwargs (line 1057) | def default_conv3d_transpose_kwargs():
  function default_dense_kwargs (line 1062) | def default_dense_kwargs():
  function default_dropout_kwargs (line 1107) | def default_dropout_kwargs():
  function default_flatten_kwargs (line 1112) | def default_flatten_kwargs():
  function default_max_pooling1d_kwargs (line 1116) | def default_max_pooling1d_kwargs():
  function default_max_pooling2d_kwargs (line 1121) | def default_max_pooling2d_kwargs():
  function default_max_pooling3d_kwargs (line 1126) | def default_max_pooling3d_kwargs():
  function default_separable_conv2d_kwargs (line 1131) | def default_separable_conv2d_kwargs():
  function default_batch_normalization_kwargs (line 1136) | def default_batch_normalization_kwargs():
  function default_average_pooling1d_kwargs (line 1141) | def default_average_pooling1d_kwargs():
  function default_average_pooling2d_kwargs (line 1146) | def default_average_pooling2d_kwargs():
  function default_average_pooling3d_kwargs (line 1151) | def default_average_pooling3d_kwargs():
  function layer_normalize (line 1175) | def layer_normalize(inputs,
  function gelu (line 1192) | def gelu(input_tensor):

FILE: texar_repo/texar/core/layers_test.py
  class GetRNNCellTest (line 24) | class GetRNNCellTest(tf.test.TestCase):
    method test_get_rnn_cell (line 28) | def test_get_rnn_cell(self):
    method test_switch_dropout (line 95) | def test_switch_dropout(self):
  class GetActivationFnTest (line 129) | class GetActivationFnTest(tf.test.TestCase):
    method test_get_activation_fn (line 132) | def test_get_activation_fn(self):
  class GetLayerTest (line 160) | class GetLayerTest(tf.test.TestCase):
    method test_get_layer (line 163) | def test_get_layer(self):
  class ReducePoolingLayerTest (line 197) | class ReducePoolingLayerTest(tf.test.TestCase):
    method setUp (line 200) | def setUp(self):
    method test_max_reduce_pooling_layer (line 207) | def test_max_reduce_pooling_layer(self):
    method test_average_reduce_pooling_layer (line 225) | def test_average_reduce_pooling_layer(self):
  class MergeLayerTest (line 243) | class MergeLayerTest(tf.test.TestCase):
    method test_output_shape (line 247) | def test_output_shape(self):
    method test_layer_logics (line 265) | def test_layer_logics(self):
    method test_trainable_variables (line 287) | def test_trainable_variables(self):
  class SequentialLayerTest (line 304) | class SequentialLayerTest(tf.test.TestCase):
    method test_seq_layer (line 308) | def test_seq_layer(self):

FILE: texar_repo/texar/core/optimization.py
  function default_optimization_hparams (line 40) | def default_optimization_hparams():
  function get_optimizer_fn (line 173) | def get_optimizer_fn(hparams=None):
  function get_learning_rate_decay_fn (line 231) | def get_learning_rate_decay_fn(hparams=None):
  function get_gradient_clip_fn (line 294) | def get_gradient_clip_fn(hparams=None):
  function _get_static_lr (line 353) | def _get_static_lr(learning_rate=None, optimizer_class=None, hparams=None):
  function get_optimizer (line 368) | def get_optimizer(learning_rate=None, global_step=None, hparams=None):
  function get_train_op (line 410) | def get_train_op(loss, variables=None,
  class AdamWeightDecayOptimizer (line 482) | class AdamWeightDecayOptimizer(tf.train.Optimizer):
    method __init__ (line 491) | def __init__(self,
    method apply_gradients (line 510) | def apply_gradients(self, grads_and_vars, global_step=None, name=None):
    method _do_use_weight_decay (line 575) | def _do_use_weight_decay(self, param_name):
    method _get_variable_name (line 585) | def _get_variable_name(self, param_name):

FILE: texar_repo/texar/core/optimization_test.py
  class OptimizationTest (line 19) | class OptimizationTest(tf.test.TestCase):
    method test_get_optimizer (line 23) | def test_get_optimizer(self):
    method test_get_learning_rate_decay_fn (line 62) | def test_get_learning_rate_decay_fn(self): # pylint: disable=too-many-...
    method test_get_gradient_clip_fn (line 106) | def test_get_gradient_clip_fn(self):    # pylint: disable=too-many-locals
    method test_get_train_op (line 149) | def test_get_train_op(self):

FILE: texar_repo/texar/core/replay_memories.py
  class ReplayMemoryBase (line 32) | class ReplayMemoryBase(object):
    method __init__ (line 40) | def __init__(self, hparams=None):
    method default_hparams (line 44) | def default_hparams():
    method add (line 57) | def add(self, element):
    method get (line 62) | def get(self, size):
    method last (line 67) | def last(self):
    method size (line 72) | def size(self):
  class DequeReplayMemory (line 78) | class DequeReplayMemory(ReplayMemoryBase):
    method __init__ (line 88) | def __init__(self, hparams=None):
    method default_hparams (line 94) | def default_hparams():
    method add (line 115) | def add(self, element):
    method get (line 124) | def get(self, size):
    method last (line 130) | def last(self):
    method size (line 135) | def size(self):

FILE: texar_repo/texar/data/data/data_base.py
  class DataBase (line 35) | class DataBase(object):
    method __init__ (line 39) | def __init__(self, hparams):
    method default_hparams (line 43) | def default_hparams():
    method _make_batch (line 148) | def _make_batch(dataset, hparams, padded_batch=False, padding_values=N...
    method _shuffle_dataset (line 166) | def _shuffle_dataset(dataset, hparams, dataset_files):
    method num_epochs (line 194) | def num_epochs(self):
    method batch_size (line 200) | def batch_size(self):
    method hparams (line 206) | def hparams(self):
    method name (line 213) | def name(self):

FILE: texar_repo/texar/data/data/data_iterators.py
  class DataIteratorBase (line 36) | class DataIteratorBase(object):
    method __init__ (line 54) | def __init__(self, datasets):
    method num_datasets (line 76) | def num_datasets(self):
    method dataset_names (line 82) | def dataset_names(self):
  class DataIterator (line 88) | class DataIterator(DataIteratorBase):
    method __init__ (line 133) | def __init__(self, datasets):
    method switch_to_dataset (line 146) | def switch_to_dataset(self, sess, dataset_name=None):
    method get_next (line 164) | def get_next(self):
  class TrainTestDataIterator (line 169) | class TrainTestDataIterator(DataIterator):
    method __init__ (line 211) | def __init__(self, train=None, val=None, test=None):
    method switch_to_train_data (line 229) | def switch_to_train_data(self, sess):
    method switch_to_val_data (line 239) | def switch_to_val_data(self, sess):
    method switch_to_test_data (line 249) | def switch_to_test_data(self, sess):
  class FeedableDataIterator (line 259) | class FeedableDataIterator(DataIteratorBase):
    method __init__ (line 320) | def __init__(self, datasets):
    method get_handle (line 337) | def get_handle(self, sess, dataset_name=None):
    method restart_dataset (line 368) | def restart_dataset(self, sess, dataset_name=None):
    method initialize_dataset (line 380) | def initialize_dataset(self, sess, dataset_name=None):
    method get_next (line 398) | def get_next(self):
    method handle (line 404) | def handle(self):
  class TrainTestFeedableDataIterator (line 410) | class TrainTestFeedableDataIterator(FeedableDataIterator):
    method __init__ (line 468) | def __init__(self, train=None, val=None, test=None):
    method get_train_handle (line 485) | def get_train_handle(self, sess):
    method get_val_handle (line 509) | def get_val_handle(self, sess):
    method get_test_handle (line 523) | def get_test_handle(self, sess):
    method restart_train_dataset (line 537) | def restart_train_dataset(self, sess):
    method restart_val_dataset (line 548) | def restart_val_dataset(self, sess):
    method restart_test_dataset (line 559) | def restart_test_dataset(self, sess):

FILE: texar_repo/texar/data/data/data_iterators_test.py
  class DataIteratorTest (line 22) | class DataIteratorTest(tf.test.TestCase):
    method setUp (line 26) | def setUp(self):
    method test_iterator_single_dataset (line 77) | def test_iterator_single_dataset(self):
    method test_iterator_multi_datasets (line 106) | def test_iterator_multi_datasets(self):
    method test_train_test_data_iterator (line 151) | def test_train_test_data_iterator(self):
    method test_feedable_iterator_multi_datasets (line 195) | def test_feedable_iterator_multi_datasets(self):
    method test_train_test_feedable_data_iterator (line 247) | def test_train_test_feedable_data_iterator(self):

FILE: texar_repo/texar/data/data/dataset_utils.py
  class _DataSpec (line 43) | class _DataSpec(object):
    method __init__ (line 55) | def __init__(self, dataset=None, dataset_size=None, decoder=None,
    method add_spec (line 64) | def add_spec(self, **kwargs):
    method get_ith_data_spec (line 69) | def get_ith_data_spec(self, i):
    method set_ith_data_spec (line 78) | def set_ith_data_spec(self, i, data_spec, total_count):
  function _make_length_filter_fn (line 96) | def _make_length_filter_fn(length_name, max_length):
  function _make_smaller_batch_filter_fn (line 104) | def _make_smaller_batch_filter_fn(batch_size):
  function _make_combined_filter_fn (line 118) | def _make_combined_filter_fn(filter_fns, mode="and"):
  function _connect_name (line 145) | def _connect_name(lhs_name, rhs_name):
  function maybe_tuple (line 152) | def maybe_tuple(data):
  function make_partial (line 161) | def make_partial(fn, *args, **kwargs):
  function name_prefix_fn (line 169) | def name_prefix_fn(name_prefix):
  function make_chained_transformation (line 181) | def make_chained_transformation(tran_fns, *args, **kwargs):
  function make_combined_transformation (line 202) | def make_combined_transformation(tran_fns, name_prefix=None, *args, **kw...
  function random_shard_dataset (line 250) | def random_shard_dataset(dataset_size, shard_size, seed=None):

FILE: texar_repo/texar/data/data/dataset_utils_test.py
  class TransformationTest (line 21) | class TransformationTest(tf.test.TestCase):
    method test_make_chained_transformation (line 25) | def test_make_chained_transformation(self):

FILE: texar_repo/texar/data/data/mono_text_data.py
  class _LengthFilterMode (line 42) | class _LengthFilterMode(object): # pylint: disable=no-init, too-few-publ...
  function _default_mono_text_dataset_hparams (line 48) | def _default_mono_text_dataset_hparams():
  class MonoTextData (line 72) | class MonoTextData(TextDataBase):
    method __init__ (line 144) | def __init__(self, hparams):
    method default_hparams (line 150) | def default_hparams():
    method make_vocab (line 319) | def make_vocab(hparams):
    method make_embedding (line 332) | def make_embedding(emb_hparams, token_to_id_map):
    method _make_mono_text_dataset (line 342) | def _make_mono_text_dataset(dataset_hparams):
    method _make_other_transformations (line 349) | def _make_other_transformations(other_trans_hparams, data_spec):
    method _make_processor (line 370) | def _make_processor(dataset_hparams, data_spec, chained=True,
    method _make_length_filter (line 411) | def _make_length_filter(dataset_hparams, length_name, decoder):
    method _process_dataset (line 421) | def _process_dataset(self, dataset, hparams, data_spec):
    method _make_bucket_length_fn (line 444) | def _make_bucket_length_fn(self):
    method _make_padded_text_and_id_shapes (line 454) | def _make_padded_text_and_id_shapes(dataset, dataset_hparams, decoder,
    method _make_padded_shapes (line 487) | def _make_padded_shapes(self, dataset, decoder):
    method _make_data (line 500) | def _make_data(self):
    method list_items (line 536) | def list_items(self):
    method dataset (line 545) | def dataset(self):
    method dataset_size (line 551) | def dataset_size(self):
    method vocab (line 564) | def vocab(self):
    method embedding_init_value (line 570) | def embedding_init_value(self):
    method text_name (line 579) | def text_name(self):
    method length_name (line 588) | def length_name(self):
    method text_id_name (line 597) | def text_id_name(self):
    method utterance_cnt_name (line 606) | def utterance_cnt_name(self):

FILE: texar_repo/texar/data/data/mono_text_data_test.py
  class MonoTextDataTest (line 23) | class MonoTextDataTest(tf.test.TestCase):
    method setUp (line 27) | def setUp(self):
    method _run_and_test (line 53) | def _run_and_test(self,
    method test_default_setting (line 118) | def test_default_setting(self):
    method test_batching (line 123) | def test_batching(self):
    method test_bucketing (line 131) | def test_bucketing(self):
    method test_shuffle (line 183) | def test_shuffle(self):
    method test_prefetch (line 192) | def test_prefetch(self):
    method test_other_transformations (line 199) | def test_other_transformations(self):
    method test_list_items (line 211) | def test_list_items(self):
    method test_length_discard (line 224) | def test_length_discard(self):
    method test_length_truncate (line 232) | def test_length_truncate(self):
    method test_pad_to_max_length (line 242) | def test_pad_to_max_length(self):
  class VarUttMonoTextDataTest (line 252) | class VarUttMonoTextDataTest(tf.test.TestCase):
    method setUp (line 256) | def setUp(self):
    method _run_and_test (line 294) | def _run_and_test(self, hparams):
    method test_default_setting (line 338) | def test_default_setting(self):
    method test_pad_to_max_length (line 343) | def test_pad_to_max_length(self):

FILE: texar_repo/texar/data/data/multi_aligned_data.py
  class _DataTypes (line 48) | class _DataTypes(object): # pylint: disable=no-init, too-few-public-methods
  function _is_text_data (line 55) | def _is_text_data(data_type):
  function _is_scalar_data (line 57) | def _is_scalar_data(data_type):
  function _default_dataset_hparams (line 60) | def _default_dataset_hparams(data_type=None):
  class MultiAlignedData (line 77) | class MultiAlignedData(TextDataBase):
    method __init__ (line 120) | def __init__(self, hparams):
    method default_hparams (line 136) | def default_hparams():
    method _raise_sharing_error (line 224) | def _raise_sharing_error(err_data, shr_data, hparam_name):
    method make_vocab (line 230) | def make_vocab(hparams):
    method make_embedding (line 286) | def make_embedding(hparams, vocabs):
    method _make_dataset (line 323) | def _make_dataset(self):
    method _get_name_prefix (line 361) | def _get_name_prefix(dataset_hparams):
    method _make_processor (line 369) | def _make_processor(dataset_hparams, data_spec, name_prefix):
    method _make_length_filter (line 406) | def _make_length_filter(dataset_hparams, length_name, decoder):
    method _process_dataset (line 418) | def _process_dataset(self, dataset, hparams, data_spec):
    method _make_bucket_length_fn (line 451) | def _make_bucket_length_fn(self):
    method _make_padded_shapes (line 467) | def _make_padded_shapes(self, dataset, decoders):
    method _make_data (line 482) | def _make_data(self):
    method list_items (line 516) | def list_items(self):
    method dataset (line 525) | def dataset(self):
    method dataset_size (line 530) | def dataset_size(self):
    method _maybe_name_to_id (line 542) | def _maybe_name_to_id(self, name_or_id):
    method vocab (line 549) | def vocab(self, name_or_id):
    method embedding_init_value (line 559) | def embedding_init_value(self, name_or_id):
    method text_name (line 566) | def text_name(self, name_or_id):
    method length_name (line 578) | def length_name(self, name_or_id):
    method text_id_name (line 590) | def text_id_name(self, name_or_id):
    method utterance_cnt_name (line 602) | def utterance_cnt_name(self, name_or_id):
    method data_name (line 616) | def data_name(self, name_or_id):

FILE: texar_repo/texar/data/data/multi_aligned_data_test.py
  class MultiAlignedDataTest (line 22) | class MultiAlignedDataTest(tf.test.TestCase):
    method setUp (line 26) | def setUp(self):
    method _run_and_test (line 95) | def _run_and_test(self, hparams, discard_did=None):
    method test_default_setting (line 159) | def test_default_setting(self):
    method test_length_filter (line 164) | def test_length_filter(self):

FILE: texar_repo/texar/data/data/paired_text_data.py
  function _default_paired_text_dataset_hparams (line 45) | def _default_paired_text_dataset_hparams():
  class PairedTextData (line 68) | class PairedTextData(TextDataBase):
    method __init__ (line 138) | def __init__(self, hparams):
    method default_hparams (line 144) | def default_hparams():
    method make_vocab (line 238) | def make_vocab(src_hparams, tgt_hparams):
    method make_embedding (line 279) | def make_embedding(src_emb_hparams, src_token_to_id_map,
    method _make_dataset (line 299) | def _make_dataset(self):
    method _get_name_prefix (line 309) | def _get_name_prefix(src_hparams, tgt_hparams):
    method _make_processor (line 318) | def _make_processor(src_hparams, tgt_hparams, data_spec, name_prefix):
    method _make_length_filter (line 349) | def _make_length_filter(src_hparams, tgt_hparams,
    method _process_dataset (line 360) | def _process_dataset(self, dataset, hparams, data_spec):
    method _make_bucket_length_fn (line 391) | def _make_bucket_length_fn(self):
    method _make_padded_shapes (line 401) | def _make_padded_shapes(self, dataset, src_decoder, tgt_decoder):
    method _make_data (line 422) | def _make_data(self):
    method list_items (line 469) | def list_items(self):
    method dataset (line 478) | def dataset(self):
    method dataset_size (line 483) | def dataset_size(self):
    method vocab (line 496) | def vocab(self):
    method source_vocab (line 503) | def source_vocab(self):
    method target_vocab (line 509) | def target_vocab(self):
    method source_embedding_init_value (line 515) | def source_embedding_init_value(self):
    method target_embedding_init_value (line 524) | def target_embedding_init_value(self):
    method embedding_init_value (line 532) | def embedding_init_value(self):
    method source_text_name (line 541) | def source_text_name(self):
    method source_length_name (line 550) | def source_length_name(self):
    method source_text_id_name (line 559) | def source_text_id_name(self):
    method source_utterance_cnt_name (line 569) | def source_utterance_cnt_name(self):
    method target_text_name (line 582) | def target_text_name(self):
    method target_length_name (line 591) | def target_length_name(self):
    method target_text_id_name (line 600) | def target_text_id_name(self):
    method target_utterance_cnt_name (line 610) | def target_utterance_cnt_name(self):
    method text_name (line 623) | def text_name(self):
    method length_name (line 629) | def length_name(self):
    method text_id_name (line 635) | def text_id_name(self):
    method utterance_cnt_name (line 641) | def utterance_cnt_name(self):

FILE: texar_repo/texar/data/data/paired_text_data_test.py
  class PairedTextDataTest (line 24) | class PairedTextDataTest(tf.test.TestCase):
    method setUp (line 28) | def setUp(self):
    method _run_and_test (line 65) | def _run_and_test(self, hparams, proc_shr=False, length_inc=None,
    method test_default_setting (line 128) | def test_default_setting(self):
    method test_shuffle (line 133) | def test_shuffle(self):
    method test_processing_share (line 140) | def test_processing_share(self):
    method test_other_transformations (line 147) | def test_other_transformations(self):
    method test_length_filter (line 161) | def test_length_filter(self):

FILE: texar_repo/texar/data/data/scalar_data.py
  function _default_scalar_dataset_hparams (line 39) | def _default_scalar_dataset_hparams():
  class ScalarData (line 53) | class ScalarData(DataBase):
    method __init__ (line 89) | def __init__(self, hparams):
    method default_hparams (line 95) | def default_hparams():
    method _get_dtype (line 159) | def _get_dtype(dtype_hparam):
    method _make_processor (line 169) | def _make_processor(dataset_hparams, data_spec, chained=True,
    method _process_dataset (line 190) | def _process_dataset(self, dataset, hparams, data_spec):
    method _make_data (line 204) | def _make_data(self):
    method list_items (line 231) | def list_items(self):
    method dataset (line 240) | def dataset(self):
    method dataset_size (line 245) | def dataset_size(self):
    method data_name (line 258) | def data_name(self):

FILE: texar_repo/texar/data/data/scalar_data_test.py
  class ScalarDataTest (line 20) | class ScalarDataTest(tf.test.TestCase):
    method setUp (line 24) | def setUp(self):
    method _run_and_test (line 59) | def _run_and_test(self, hparams):
    method test_default_setting (line 94) | def test_default_setting(self):
    method test_shuffle (line 100) | def test_shuffle(self):

FILE: texar_repo/texar/data/data/text_data_base.py
  class TextDataBase (line 34) | class TextDataBase(DataBase): # pylint: disable=too-few-public-methods
    method __init__ (line 38) | def __init__(self, hparams):
    method default_hparams (line 42) | def default_hparams():
    method _make_batch (line 55) | def _make_batch(dataset, hparams, element_length_func,

FILE: texar_repo/texar/data/data_decoders.py
  function _append_token (line 41) | def _append_token(token):
  class ScalarDataDecoder (line 44) | class ScalarDataDecoder(data_decoder.DataDecoder):
    method __init__ (line 55) | def __init__(self, dtype=tf.int32, data_name="data"):
    method __call__ (line 61) | def __call__(self, data):
    method decode (line 65) | def decode(self, data, items):
    method list_items (line 87) | def list_items(self):
    method data_tensor_name (line 96) | def data_tensor_name(self):
  class TextDataDecoder (line 101) | class TextDataDecoder(data_decoder.DataDecoder):
    method __init__ (line 134) | def __init__(self,
    method __call__ (line 155) | def __call__(self, data):
    method decode (line 159) | def decode(self, data, items):
    method list_items (line 205) | def list_items(self):
    method text_tensor_name (line 216) | def text_tensor_name(self):
    method text_tensor_name (line 222) | def text_tensor_name(self, name):
    method length_tensor_name (line 226) | def length_tensor_name(self):
    method length_tensor_name (line 232) | def length_tensor_name(self, name):
    method text_id_tensor_name (line 236) | def text_id_tensor_name(self):
    method text_id_tensor_name (line 242) | def text_id_tensor_name(self, name):
    method added_length (line 246) | def added_length(self):
  class VarUttTextDataDecoder (line 251) | class VarUttTextDataDecoder(data_decoder.DataDecoder):
    method __init__ (line 292) | def __init__(self,
    method __call__ (line 319) | def __call__(self, data):
    method decode (line 323) | def decode(self, data, items): # pylint: disable=too-many-locals
    method list_items (line 409) | def list_items(self):
    method text_tensor_name (line 423) | def text_tensor_name(self):
    method text_tensor_name (line 429) | def text_tensor_name(self, name):
    method utterance_cnt_tensor_name (line 433) | def utterance_cnt_tensor_name(self):
    method length_tensor_name (line 439) | def length_tensor_name(self):
    method length_tensor_name (line 445) | def length_tensor_name(self, name):
    method text_id_tensor_name (line 449) | def text_id_tensor_name(self):
    method text_id_tensor_name (line 455) | def text_id_tensor_name(self, name):
    method added_length (line 459) | def added_length(self):

FILE: texar_repo/texar/data/data_utils.py
  function maybe_download (line 47) | def maybe_download(urls, path, filenames=None, extract=False):
  function _download (line 107) | def _download(url, filename, path):
  function _extract_google_drive_file_id (line 124) | def _extract_google_drive_file_id(url):
  function _download_from_google_drive (line 130) | def _download_from_google_drive(url, filename, path):
  function read_words (line 161) | def read_words(filename, newline_token=None):
  function make_vocab (line 188) | def make_vocab(filenames, max_vocab_size=-1, newline_token=None,
  function count_file_lines (line 248) | def count_file_lines(filenames):

FILE: texar_repo/texar/data/data_utils_test.py
  class CountFileLinesTest (line 19) | class CountFileLinesTest(tf.test.TestCase):
    method test_load_glove (line 23) | def test_load_glove(self):

FILE: texar_repo/texar/data/embedding.py
  function load_word2vec (line 36) | def load_word2vec(filename, vocab, word_vecs):
  function load_glove (line 76) | def load_glove(filename, vocab, word_vecs):
  class Embedding (line 107) | class Embedding(object):
    method __init__ (line 119) | def __init__(self, vocab, hparams=None):
    method default_hparams (line 148) | def default_hparams():
    method word_vecs (line 228) | def word_vecs(self):
    method vector_size (line 234) | def vector_size(self):

FILE: texar_repo/texar/data/embedding_test.py
  class EmbeddingTest (line 34) | class EmbeddingTest(tf.test.TestCase):
    method test_load_glove (line 38) | def test_load_glove(self):
    method test_load_word2vec (line 58) | def test_load_word2vec(self):
    method test_embedding (line 80) | def test_embedding(self):

FILE: texar_repo/texar/data/vocabulary.py
  class SpecialTokens (line 41) | class SpecialTokens(object):
  function _make_defaultdict (line 52) | def _make_defaultdict(keys, values, default_value):
  class Vocab (line 71) | class Vocab(object):
    method __init__ (line 94) | def __init__(self,
    method load (line 110) | def load(self, filename):
    method map_ids_to_tokens (line 174) | def map_ids_to_tokens(self, ids):
    method map_tokens_to_ids (line 187) | def map_tokens_to_ids(self, tokens):
    method map_ids_to_tokens_py (line 200) | def map_ids_to_tokens_py(self, ids):
    method map_tokens_to_ids_py (line 214) | def map_tokens_to_ids_py(self, tokens):
    method id_to_token_map (line 229) | def id_to_token_map(self):
    method token_to_id_map (line 236) | def token_to_id_map(self):
    method id_to_token_map_py (line 243) | def id_to_token_map_py(self):
    method token_to_id_map_py (line 250) | def token_to_id_map_py(self):
    method size (line 257) | def size(self):
    method bos_token (line 263) | def bos_token(self):
    method bos_token_id (line 269) | def bos_token_id(self):
    method eos_token (line 276) | def eos_token(self):
    method eos_token_id (line 282) | def eos_token_id(self):
    method unk_token (line 289) | def unk_token(self):
    method unk_token_id (line 295) | def unk_token_id(self):
    method pad_token (line 301) | def pad_token(self):
    method pad_token_id (line 308) | def pad_token_id(self):
    method special_tokens (line 314) | def special_tokens(self):

FILE: texar_repo/texar/data/vocabulary_test.py
  class VocabularyTest (line 19) | class VocabularyTest(tf.test.TestCase):
    method test_make_defaultdict (line 23) | def test_make_defaultdict(self):
    method test_vocab_construction (line 37) | def test_vocab_construction(self):

FILE: texar_repo/texar/evals/bleu.py
  function _get_ngrams (line 47) | def _get_ngrams(segment, max_order):
  function _maybe_str_to_list (line 66) | def _maybe_str_to_list(list_or_str):
  function _lowercase (line 71) | def _lowercase(str_list):
  function sentence_bleu (line 74) | def sentence_bleu(references, hypothesis, max_order=4, lowercase=False,
  function corpus_bleu (line 103) | def corpus_bleu(list_of_references, hypotheses, max_order=4, lowercase=F...

FILE: texar_repo/texar/evals/bleu_moses.py
  function _maybe_list_to_str (line 43) | def _maybe_list_to_str(list_or_str):
  function _parse_multi_bleu_ret (line 48) | def _parse_multi_bleu_ret(bleu_str, return_all=False):
  function sentence_bleu_moses (line 60) | def sentence_bleu_moses(references, hypothesis, lowercase=False,
  function corpus_bleu_moses (line 86) | def corpus_bleu_moses(list_of_references, hypotheses, lowercase=False,

FILE: texar_repo/texar/evals/bleu_test.py
  class BLEUTest (line 21) | class BLEUTest(tf.test.TestCase):
    method _test_sentence_bleu (line 25) | def _test_sentence_bleu(self, references, hypothesis, lowercase,
    method test_sentence_strings (line 37) | def test_sentence_strings(self):
    method test_sentence_list (line 46) | def test_sentence_list(self):
    method test_sentence_multi_references (line 57) | def test_sentence_multi_references(self):
    method test_sentence_numpy (line 67) | def test_sentence_numpy(self):
    method _test_corpus_bleu (line 80) | def _test_corpus_bleu(self, list_of_references, hypotheses, lowercase,
    method test_corpus_strings (line 104) | def test_corpus_strings(self):

FILE: texar_repo/texar/evals/metrics.py
  function accuracy (line 17) | def accuracy(labels, preds):
  function binary_clas_accuracy (line 31) | def binary_clas_accuracy(pos_preds=None, neg_preds=None):

FILE: texar_repo/texar/hyperparams.py
  function _type_name (line 31) | def _type_name(value):
  class HParams (line 34) | class HParams(object):
    method __init__ (line 151) | def __init__(self, hparams, default_hparams, allow_new_hparam=False):
    method _parse (line 162) | def _parse(hparams, # pylint: disable=too-many-branches, too-many-stat...
    method _parse_value (line 284) | def _parse_value(value, name=None):
    method __getattr__ (line 290) | def __getattr__(self, name):
    method __getitem__ (line 300) | def __getitem__(self, name):
    method __setattr__ (line 305) | def __setattr__(self, name, value):
    method items (line 315) | def items(self):
    method keys (line 320) | def keys(self):
    method __iter__ (line 325) | def __iter__(self):
    method __len__ (line 329) | def __len__(self):
    method __contains__ (line 332) | def __contains__(self, name):
    method __str__ (line 335) | def __str__(self):
    method get (line 341) | def get(self, name, default=None):
    method add_hparam (line 354) | def add_hparam(self, name, value):
    method todict (line 361) | def todict(self):

FILE: texar_repo/texar/hyperparams_test.py
  class HParamsTest (line 19) | class HParamsTest(tf.test.TestCase):
    method test_hparams (line 23) | def test_hparams(self):
    method test_typecheck (line 99) | def test_typecheck(self):
    method test_type_kwargs (line 119) | def test_type_kwargs(self):

FILE: texar_repo/texar/losses/adv_losses.py
  function binary_adversarial_losses (line 23) | def binary_adversarial_losses(real_data,

FILE: texar_repo/texar/losses/adv_losses_test.py
  class AdvLossesTest (line 14) | class AdvLossesTest(tf.test.TestCase):
    method test_binary_adversarial_losses (line 17) | def test_binary_adversarial_losses(self):

FILE: texar_repo/texar/losses/entropy.py
  function _get_entropy (line 34) | def _get_entropy(logits):
  function entropy_with_logits (line 40) | def entropy_with_logits(logits,
  function sequence_entropy_with_logits (line 116) | def sequence_entropy_with_logits(logits,

FILE: texar_repo/texar/losses/losses_utils.py
  function mask_and_reduce (line 38) | def mask_and_reduce(sequence,
  function reduce_batch_time (line 129) | def reduce_batch_time(sequence,
  function reduce_dimensions (line 166) | def reduce_dimensions(tensor, average_axes=None, sum_axes=None, keepdims...

FILE: texar_repo/texar/losses/mle_losses.py
  function sequence_softmax_cross_entropy (line 38) | def sequence_softmax_cross_entropy(labels,
  function sequence_sparse_softmax_cross_entropy (line 119) | def sequence_sparse_softmax_cross_entropy(labels,
  function sequence_sigmoid_cross_entropy (line 208) | def sequence_sigmoid_cross_entropy(labels,
  function binary_sigmoid_cross_entropy (line 306) | def binary_sigmoid_cross_entropy(pos_logits=None,
  function binary_sigmoid_cross_entropy_with_clas (line 384) | def binary_sigmoid_cross_entropy_with_clas(clas_fn,

FILE: texar_repo/texar/losses/mle_losses_test.py
  class MLELossesTest (line 20) | class MLELossesTest(tf.test.TestCase):
    method setUp (line 24) | def setUp(self):
    method _test_sequence_loss (line 40) | def _test_sequence_loss(self, loss_fn, labels, logits, sequence_length):
    method test_sequence_softmax_cross_entropy (line 75) | def test_sequence_softmax_cross_entropy(self):
    method test_sequence_sparse_softmax_cross_entropy (line 82) | def test_sequence_sparse_softmax_cross_entropy(self):
    method test_sequence_sigmoid_cross_entropy (line 89) | def test_sequence_sigmoid_cross_entropy(self):

FILE: texar_repo/texar/losses/pg_losses.py
  function pg_loss_with_logits (line 34) | def pg_loss_with_logits(actions,
  function pg_loss_with_log_probs (line 136) | def pg_loss_with_log_probs(log_probs,

FILE: texar_repo/texar/losses/rewards.py
  function discount_reward (line 37) | def discount_reward(reward,
  function _discount_reward_py_1d (line 122) | def _discount_reward_py_1d(reward, sequence_length, discount=1., dtype=N...
  function _discount_reward_tensor_1d (line 149) | def _discount_reward_tensor_1d(reward, sequence_length,
  function _discount_reward_py_2d (line 174) | def _discount_reward_py_2d(reward, sequence_length=None,
  function _discount_reward_tensor_2d (line 191) | def _discount_reward_tensor_2d(reward, sequence_length=None,

FILE: texar_repo/texar/losses/rewards_test.py
  class RewardTest (line 21) | class RewardTest(tf.test.TestCase):
    method test_discount_reward (line 25) | def test_discount_reward(self):
    method test_discount_reward_py_1d (line 80) | def test_discount_reward_py_1d(self):
    method test_discount_reward_tensor_1d (line 108) | def test_discount_reward_tensor_1d(self):
    method test_discount_reward_py_2d (line 139) | def test_discount_reward_py_2d(self):
    method test_discount_reward_tensor_2d (line 167) | def test_discount_reward_tensor_2d(self):

FILE: texar_repo/texar/losses/rl_losses.py
  function reinforce_loss (line 27) | def reinforce_loss(sample_fn,
  function reinforce_loss_with_MCtree (line 79) | def reinforce_loss_with_MCtree(sample_fn,   # pylint: disable=invalid-name

FILE: texar_repo/texar/models/model_base.py
  class ModelBase (line 30) | class ModelBase(object):
    method __init__ (line 43) | def __init__(self, hparams=None):
    method default_hparams (line 48) | def default_hparams():
    method __call__ (line 56) | def __call__(self, features, labels, params, mode, config=None):
    method _build (line 63) | def _build(self, features, labels, params, mode, config=None):
    method get_input_fn (line 70) | def get_input_fn(self, *args, **kwargs):
    method hparams (line 77) | def hparams(self):

FILE: texar_repo/texar/models/seq2seq/basic_seq2seq.py
  class BasicSeq2seq (line 35) | class BasicSeq2seq(Seq2seqBase):
    method __init__ (line 55) | def __init__(self, data_hparams, hparams=None):
    method default_hparams (line 59) | def default_hparams():
    method _build_decoder (line 71) | def _build_decoder(self):
    method _get_predictions (line 80) | def _get_predictions(self, decoder_results, features, labels, loss=None):
    method embed_source (line 97) | def embed_source(self, features, labels, mode):
    method embed_target (line 102) | def embed_target(self, features, labels, mode):
    method encode (line 107) | def encode(self, features, labels, mode):
    method _connect (line 119) | def _connect(self, encoder_results, features, labels, mode):
    method _decode_train (line 131) | def _decode_train(self, initial_state, encoder_results, features,
    method _decode_infer (line 140) | def _decode_infer(self, initial_state, encoder_results, features,
    method decode (line 165) | def decode(self, encoder_results, features, labels, mode):

FILE: texar_repo/texar/models/seq2seq/seq2seq_base.py
  class Seq2seqBase (line 39) | class Seq2seqBase(ModelBase):
    method __init__ (line 46) | def __init__(self, data_hparams, hparams=None):
    method default_hparams (line 61) | def default_hparams():
    method _build_vocab (line 162) | def _build_vocab(self):
    method _build_embedders (line 167) | def _build_embedders(self):
    method _build_encoder (line 192) | def _build_encoder(self):
    method _build_decoder (line 200) | def _build_decoder(self):
    method _build_connector (line 203) | def _build_connector(self):
    method get_loss (line 212) | def get_loss(self, decoder_results, features, labels):
    method _get_predictions (line 220) | def _get_predictions(self, decoder_results, features, labels, loss=None):
    method _get_train_op (line 223) | def _get_train_op(self, loss):
    method _get_eval_metric_ops (line 230) | def _get_eval_metric_ops(self, decoder_results, features, labels):
    method embed_source (line 233) | def embed_source(self, features, labels, mode):
    method embed_target (line 238) | def embed_target(self, features, labels, mode):
    method encode (line 243) | def encode(self, features, labels, mode):
    method _connect (line 248) | def _connect(self, encoder_results, features, labels, mode):
    method decode (line 253) | def decode(self, encoder_results, features, labels, mode):
    method _build (line 258) | def _build(self, features, labels, params, mode, config=None):
    method get_input_fn (line 290) | def get_input_fn(self, mode, hparams=None): #pylint:disable=arguments-...

FILE: texar_repo/texar/module_base.py
  class ModuleBase (line 32) | class ModuleBase(object):
    method __init__ (line 70) | def __init__(self, hparams=None):
    method default_hparams (line 79) | def default_hparams():
    method _build (line 94) | def _build(self, *args, **kwargs):
    method __call__ (line 106) | def __call__(self, *args, **kwargs):
    method _add_internal_trainable_variables (line 118) | def _add_internal_trainable_variables(self):  # pylint: disable=invali...
    method _add_trainable_variable (line 133) | def _add_trainable_variable(self, variable):
    method variable_scope (line 150) | def variable_scope(self):
    method name (line 156) | def name(self):
    method trainable_variables (line 162) | def trainable_variables(self):
    method hparams (line 173) | def hparams(self):

FILE: texar_repo/texar/modules/classifiers/classifier_base.py
  class ClassifierBase (line 28) | class ClassifierBase(ModuleBase):
    method __init__ (line 32) | def __init__(self, hparams=None):
    method default_hparams (line 36) | def default_hparams():
    method _build (line 43) | def _build(self, inputs, *args, **kwargs):

FILE: texar_repo/texar/modules/classifiers/conv_classifiers.py
  class Conv1DClassifier (line 36) | class Conv1DClassifier(ClassifierBase):
    method __init__ (line 62) | def __init__(self, hparams=None):
    method default_hparams (line 92) | def default_hparams():
    method _build (line 143) | def _build(self,    # pylint: disable=arguments-differ
    method trainable_variables (line 199) | def trainable_variables(self):
    method num_classes (line 210) | def num_classes(self):
    method nn (line 216) | def nn(self): # pylint: disable=invalid-name
    method has_layer (line 221) | def has_layer(self, layer_name):
    method layer_by_name (line 230) | def layer_by_name(self, layer_name):
    method layers_by_name (line 240) | def layers_by_name(self):
    method layers (line 246) | def layers(self):
    method layer_names (line 252) | def layer_names(self):
    method layer_outputs_by_name (line 257) | def layer_outputs_by_name(self, layer_name):
    method layer_outputs (line 267) | def layer_outputs(self):

FILE: texar_repo/texar/modules/classifiers/conv_classifiers_test.py
  class Conv1DClassifierTest (line 17) | class Conv1DClassifierTest(tf.test.TestCase):
    method test_classifier (line 21) | def test_classifier(self):

FILE: texar_repo/texar/modules/classifiers/rnn_classifiers.py
  class UnidirectionalRNNClassifier (line 49) | class UnidirectionalRNNClassifier(ClassifierBase):
    method __init__ (line 80) | def __init__(self,
    method default_hparams (line 121) | def default_hparams():
    method _build (line 190) | def _build(self,
    method num_classes (line 345) | def num_classes(self):

FILE: texar_repo/texar/modules/classifiers/rnn_classifiers_test.py
  class UnidirectionalRNNClassifierTest (line 20) | class UnidirectionalRNNClassifierTest(tf.test.TestCase):
    method test_trainable_variables (line 24) | def test_trainable_variables(self):
    method test_encode (line 46) | def test_encode(self):
    method test_binary (line 118) | def test_binary(self):

FILE: texar_repo/texar/modules/connectors/connector_base.py
  class ConnectorBase (line 28) | class ConnectorBase(ModuleBase):
    method __init__ (line 49) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 54) | def default_hparams():
    method _build (line 61) | def _build(self, *args, **kwargs):
    method output_size (line 67) | def output_size(self):

FILE: texar_repo/texar/modules/connectors/connectors.py
  function _assert_same_size (line 44) | def _assert_same_size(outputs, output_size):
  function _get_tensor_depth (line 61) | def _get_tensor_depth(x):
  function _mlp_transform (line 70) | def _mlp_transform(inputs, output_size, activation_fn=tf.identity):
  class ConstantConnector (line 124) | class ConstantConnector(ConnectorBase):
    method __init__ (line 155) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 159) | def default_hparams():
    method _build (line 183) | def _build(self, batch_size, value=None):
  class ForwardConnector (line 209) | class ForwardConnector(ConnectorBase):
    method __init__ (line 251) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 255) | def default_hparams():
    method _build (line 273) | def _build(self, inputs):
  class MLPTransformConnector (line 300) | class MLPTransformConnector(ConnectorBase):
    method __init__ (line 351) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 355) | def default_hparams():
    method _build (line 380) | def _build(self, inputs):
  class ReparameterizedStochasticConnector (line 405) | class ReparameterizedStochasticConnector(ConnectorBase):
    method __init__ (line 458) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 462) | def default_hparams():
    method _build (line 487) | def _build(self,
  class StochasticConnector (line 562) | class StochasticConnector(ConnectorBase):
    method __init__ (line 587) | def __init__(self, output_size, hparams=None):
    method default_hparams (line 591) | def default_hparams():
    method _build (line 616) | def _build(self,

FILE: texar_repo/texar/modules/connectors/connectors_test.py
  class TestConnectors (line 23) | class TestConnectors(tf.test.TestCase):
    method setUp (line 27) | def setUp(self):
    method test_constant_connector (line 34) | def test_constant_connector(self):
    method test_forward_connector (line 54) | def test_forward_connector(self):
    method test_mlp_transform_connector (line 61) | def test_mlp_transform_connector(self):
    method test_reparameterized_stochastic_connector (line 75) | def test_reparameterized_stochastic_connector(self):

FILE: texar_repo/texar/modules/decoders/beam_search_decode.py
  function _get_initial_state (line 36) | def _get_initial_state(initial_state,
  function beam_search_decode (line 62) | def beam_search_decode(decoder_or_cell,

FILE: texar_repo/texar/modules/decoders/beam_search_decode_test.py
  class BeamSearchDecodeTest (line 23) | class BeamSearchDecodeTest(tf.test.TestCase):
    method setUp (line 28) | def setUp(self):
    method _test_beam_search (line 45) | def _test_beam_search(
    method test_basic_rnn_decoder_beam_search (line 142) | def test_basic_rnn_decoder_beam_search(self):
    method test_basic_rnn_decoder_given_initial_state (line 159) | def test_basic_rnn_decoder_given_initial_state(self):
    method test_attention_decoder_beam_search (line 183) | def test_attention_decoder_beam_search(self):
    method test_attention_decoder_given_initial_state (line 205) | def test_attention_decoder_given_initial_state(self):

FILE: texar_repo/texar/modules/decoders/rnn_decoder_base.py
  class RNNDecoderBase (line 44) | class RNNDecoderBase(ModuleBase, TFDecoder):
    method __init__ (line 54) | def __init__(self,
    method default_hparams (line 92) | def default_hparams():
    method _build (line 109) | def _build(self,
    method _get_beam_search_cell (line 432) | def _get_beam_search_cell(self, **kwargs):
    method _rnn_output_size (line 436) | def _rnn_output_size(self):
    method batch_size (line 455) | def batch_size(self):
    method output_size (line 459) | def output_size(self):
    method output_dtype (line 465) | def output_dtype(self):
    method initialize (line 470) | def initialize(self, name=None):
    method step (line 475) | def step(self, time, inputs, state, name=None):
    method finalize (line 480) | def finalize(self, outputs, final_state, sequence_lengths):
    method cell (line 486) | def cell(self):
    method zero_state (line 491) | def zero_state(self, batch_size, dtype):
    method state_size (line 499) | def state_size(self):
    method vocab_size (line 506) | def vocab_size(self):
    method output_layer (line 512) | def output_layer(self):

FILE: texar_repo/texar/modules/decoders/rnn_decoder_helpers.py
  function default_helper_train_hparams (line 43) | def default_helper_train_hparams():
  function default_helper_infer_hparams (line 70) | def default_helper_infer_hparams():
  function get_helper (line 98) | def get_helper(helper_type,
  function _get_training_helper (line 142) | def _get_training_helper( #pylint: disable=invalid-name
  class SoftmaxEmbeddingHelper (line 188) | class SoftmaxEmbeddingHelper(TFHelper):
    method __init__ (line 216) | def __init__(self, embedding, start_tokens, end_token, tau,
    method batch_size (line 240) | def batch_size(self):
    method sample_ids_dtype (line 244) | def sample_ids_dtype(self):
    method sample_ids_shape (line 248) | def sample_ids_shape(self):
    method initialize (line 251) | def initialize(self, name=None):
    method sample (line 255) | def sample(self, time, outputs, state, name=None):
    method next_inputs (line 262) | def next_inputs(self, time, outputs, state, sample_ids, name=None):
  class GumbelSoftmaxEmbeddingHelper (line 274) | class GumbelSoftmaxEmbeddingHelper(SoftmaxEmbeddingHelper):
    method __init__ (line 308) | def __init__(self, embedding, start_tokens, end_token, tau,
    method sample (line 314) | def sample(self, time, outputs, state, name=None):

FILE: texar_repo/texar/modules/decoders/rnn_decoders.py
  class BasicRNNDecoderOutput (line 43) | class BasicRNNDecoderOutput(
  class AttentionRNNDecoderOutput (line 71) | class AttentionRNNDecoderOutput(
  class BasicRNNDecoder (line 104) | class BasicRNNDecoder(RNNDecoderBase):
    method __init__ (line 173) | def __init__(self,
    method default_hparams (line 183) | def default_hparams():
    method initialize (line 243) | def initialize(self, name=None):
    method step (line 246) | def step(self, time, inputs, state, name=None):
    method finalize (line 259) | def finalize(self, outputs, final_state, sequence_lengths):
    method output_size (line 263) | def output_size(self):
    method output_dtype (line 272) | def output_dtype(self):
  class AttentionRNNDecoder (line 286) | class AttentionRNNDecoder(RNNDecoderBase):
    method __init__ (line 350) | def __init__(self,
    method default_hparams (line 408) | def default_hparams():
    method _get_beam_search_cell (line 533) | def _get_beam_search_cell(self, beam_width):
    method initialize (line 562) | def initialize(self, name=None):
    method step (line 573) | def step(self, time, inputs, state, name=None):
    method finalize (line 593) | def finalize(self, outputs, final_state, sequence_lengths):
    method _alignments_size (line 596) | def _alignments_size(self):
    method output_size (line 613) | def output_size(self):
    method output_dtype (line 622) | def output_dtype(self):
    method zero_state (line 639) | def zero_state(self, batch_size, dtype):
    method wrapper_zero_state (line 645) | def wrapper_zero_state(self, batch_size, dtype):
    method state_size (line 652) | def state_size(self):
    method wrapper_state_size (line 660) | def wrapper_state_size(self):

FILE: texar_repo/texar/modules/decoders/rnn_decoders_test.py
  class BasicRNNDecoderTest (line 24) | class BasicRNNDecoderTest(tf.test.TestCase):
    method setUp (line 28) | def setUp(self):
    method _test_outputs (line 40) | def _test_outputs(self, decoder, outputs, final_state, sequence_lengths,
    method test_decode_train (line 66) | def test_decode_train(self):
    method test_decode_train_with_tf (line 101) | def test_decode_train_with_tf(self):
    method test_decode_infer (line 166) | def test_decode_infer(self):
  class AttentionRNNDecoderTest (line 204) | class AttentionRNNDecoderTest(tf.test.TestCase):
    method setUp (line 208) | def setUp(self):
    method test_decode_train (line 223) | def test_decode_train(self):
    method test_decode_infer (line 276) | def test_decode_infer(self):
    method test_beam_search_cell (line 326) | def test_beam_search_cell(self):

FILE: texar_repo/texar/modules/decoders/transformer_decoders.py
  class TransformerDecoderOutput (line 49) | class TransformerDecoderOutput(
  class TransformerDecoder (line 62) | class TransformerDecoder(ModuleBase):
    method __init__ (line 83) | def __init__(self, embedding, hparams=None):
    method default_hparams (line 141) | def default_hparams():
    method _prepare_tokens_to_embeds (line 248) | def _prepare_tokens_to_embeds(self, tokens):
    method _symbols_to_logits_fn (line 253) | def _symbols_to_logits_fn(self, embedding_fn, max_length):
    method _build (line 286) | def _build(self,    # pylint: disable=arguments-differ
    method _self_attention_stack (line 488) | def _self_attention_stack(self,
    method _build_output_layer (line 551) | def _build_output_layer(self, dim):
    method _init_cache (line 577) | def _init_cache(self, memory, memory_attention_bias):
    method _infer_decoding (line 593) | def _infer_decoding(self,
    method _beam_decode (line 672) | def _beam_decode(self,

FILE: texar_repo/texar/modules/decoders/transformer_decoders_test.py
  class TransformerDecoderTest (line 19) | class TransformerDecoderTest(tf.test.TestCase):
    method setUp (line 23) | def setUp(self):
    method test_train (line 43) | def test_train(self):
    method test_infer_greedy (line 65) | def test_infer_greedy(self):
    method test_infer_sample (line 85) | def test_infer_sample(self):
    method test_beam_search (line 106) | def test_beam_search(self):

FILE: texar_repo/texar/modules/embedders/embedder_base.py
  class EmbedderBase (line 33) | class EmbedderBase(ModuleBase):
    method __init__ (line 45) | def __init__(self, num_embeds=None, hparams=None):
    method _init_parameterized_embedding (line 51) | def _init_parameterized_embedding(self, init_value, num_embeds, hparams):
    method _get_dropout_layer (line 64) | def _get_dropout_layer(self, hparams, ids_rank=None, dropout_input=None,
    method default_hparams (line 93) | def default_hparams():
    method _build (line 106) | def _build(self, *args, **kwargs):
    method num_embeds (line 110) | def num_embeds(self):

FILE: texar_repo/texar/modules/embedders/embedder_utils.py
  function default_embedding_hparams (line 32) | def default_embedding_hparams():
  function get_embedding (line 168) | def get_embedding(hparams=None,
  function soft_embedding_lookup (line 218) | def soft_embedding_lookup(embedding, soft_ids):

FILE: texar_repo/texar/modules/embedders/embedder_utils_test.py
  class GetEmbeddingTest (line 17) | class GetEmbeddingTest(tf.test.TestCase):
    method test_get_embedding (line 20) | def test_get_embedding(self):

FILE: texar_repo/texar/modules/embedders/embedders.py
  class WordEmbedder (line 33) | class WordEmbedder(EmbedderBase):
    method __init__ (line 96) | def __init__(self, init_value=None, vocab_size=None, hparams=None):
    method default_hparams (line 117) | def default_hparams():
    method _build (line 191) | def _build(self, ids=None, soft_ids=None, mode=None, **kwargs):
    method embedding (line 256) | def embedding(self):
    method dim (line 262) | def dim(self):
    method vocab_size (line 268) | def vocab_size(self):

FILE: texar_repo/texar/modules/embedders/embedders_test.py
  class EmbedderTest (line 21) | class EmbedderTest(tf.test.TestCase):
    method _test_word_embedder (line 25) | def _test_word_embedder(self, hparams):
    method _test_position_embedder (line 69) | def _test_position_embedder(self, hparams):
    method test_embedder (line 101) | def test_embedder(self):
    method test_embedder_multi_calls (line 161) | def test_embedder_multi_calls(self):
    method test_word_embedder_soft_ids (line 185) | def test_word_embedder_soft_ids(self):

FILE: texar_repo/texar/modules/embedders/position_embedders.py
  class PositionEmbedder (line 38) | class PositionEmbedder(EmbedderBase):
    method __init__ (line 66) | def __init__(self, init_value=None, position_size=None, hparams=None):
    method default_hparams (line 87) | def default_hparams():
    method _build (line 121) | def _build(self, positions=None, sequence_length=None, mode=None, **kw...
    method embedding (line 205) | def embedding(self):
    method dim (line 211) | def dim(self):
    method position_size (line 217) | def position_size(self):
  class SinusoidsPositionEmbedder (line 223) | class SinusoidsPositionEmbedder(EmbedderBase):
    method __init__ (line 246) | def __init__(self, hparams=None):
    method default_hparams (line 249) | def default_hparams(self):
    method _build (line 272) | def _build(self, positions):

FILE: texar_repo/texar/modules/encoders/conv_encoders.py
  class Conv1DEncoder (line 29) | class Conv1DEncoder(Conv1DNetwork, EncoderBase):
    method __init__ (line 38) | def __init__(self, hparams=None): # pylint: disable=super-init-not-called
    method default_hparams (line 42) | def default_hparams():

FILE: texar_repo/texar/modules/encoders/conv_encoders_test.py
  class Conv1DEncoderTest (line 17) | class Conv1DEncoderTest(tf.test.TestCase):
    method test_encode (line 21) | def test_encode(self):
    method test_unknown_seq_length (line 66) | def test_unknown_seq_length(self):

FILE: texar_repo/texar/modules/encoders/encoder_base.py
  class EncoderBase (line 28) | class EncoderBase(ModuleBase):
    method __init__ (line 32) | def __init__(self, hparams=None):
    method default_hparams (line 36) | def default_hparams():
    method _build (line 43) | def _build(self, inputs, *args, **kwargs):

FILE: texar_repo/texar/modules/encoders/hierarchical_encoders.py
  class HierarchicalRNNEncoder (line 37) | class HierarchicalRNNEncoder(EncoderBase):
    method __init__ (line 66) | def __init__(self, encoder_major=None, encoder_minor=None,
    method default_hparams (line 103) | def default_hparams():
    method _build (line 170) | def _build(self,
    method tile_initial_state_minor (line 290) | def tile_initial_state_minor(initial_state, order, inputs_shape):
    method _get_flatten_order (line 323) | def _get_flatten_order(order, kwargs_minor, kwargs_major, shape):
    method flatten (line 350) | def flatten(x):
    method encoder_major (line 368) | def encoder_major(self):
    method encoder_minor (line 374) | def encoder_minor(self):

FILE: texar_repo/texar/modules/encoders/hierarchical_encoders_test.py
  class HierarchicalRNNEncoderTest (line 17) | class HierarchicalRNNEncoderTest(tf.test.TestCase):
    method test_trainable_variables (line 21) | def test_trainable_variables(self):
    method test_encode (line 36) | def test_encode(self):
    method test_order (line 57) | def test_order(self):
    method test_depack (line 80) | def test_depack(self):
    method test_encoder_minor_as_birnn (line 110) | def test_encoder_minor_as_birnn(self):

FILE: texar_repo/texar/modules/encoders/multihead_attention.py
  class MultiheadAttentionEncoder (line 36) | class MultiheadAttentionEncoder(EncoderBase):
    method __init__ (line 48) | def __init__(self, hparams=None):
    method default_hparams (line 70) | def default_hparams():
    method _build (line 121) | def _build(self, queries, memory, memory_attention_bias,
    method _split_heads (line 200) | def _split_heads(self, x):
    method _combine_heads (line 211) | def _combine_heads(self, x):

FILE: texar_repo/texar/modules/encoders/rnn_encoders.py
  function _default_output_layer_hparams (line 44) | def _default_output_layer_hparams():
  function _build_dense_output_layer (line 58) | def _build_dense_output_layer(hparams):
  function _forward_single_output_layer (line 94) | def _forward_single_output_layer(inputs, input_size, output_layer):
  function _apply_dropout (line 115) | def _apply_dropout(inputs, time_major, hparams, training):
  function _forward_output_layers (line 131) | def _forward_output_layers(inputs, input_size, output_layer, time_major,
  function _apply_rnn_encoder_output_layer (line 183) | def _apply_rnn_encoder_output_layer(output_layer, time_major, hparams, m...
  class RNNEncoderBase (line 201) | class RNNEncoderBase(EncoderBase):
    method __init__ (line 211) | def __init__(self, hparams=None):
    method default_hparams (line 215) | def default_hparams():
    method _build (line 228) | def _build(self, inputs, *args, **kwargs):
  class UnidirectionalRNNEncoder (line 242) | class UnidirectionalRNNEncoder(RNNEncoderBase):
    method __init__ (line 280) | def __init__(self,
    method default_hparams (line 306) | def default_hparams():
    method _build (line 409) | def _build(self,
    method cell (line 532) | def cell(self):
    method state_size (line 538) | def state_size(self):
    method output_layer (line 546) | def output_layer(self):
  class BidirectionalRNNEncoder (line 551) | class BidirectionalRNNEncoder(RNNEncoderBase):
    method __init__ (line 597) | def __init__(self,
    method default_hparams (line 647) | def default_hparams():
    method _build (line 730) | def _build(self,
    method cell_fw (line 878) | def cell_fw(self):
    method cell_bw (line 884) | def cell_bw(self):
    method state_size_fw (line 890) | def state_size_fw(self):
    method state_size_bw (line 898) | def state_size_bw(self):
    method output_layer_fw (line 906) | def output_layer_fw(self):
    method output_layer_bw (line 912) | def output_layer_bw(self):

FILE: texar_repo/texar/modules/encoders/rnn_encoders_test.py
  class UnidirectionalRNNEncoderTest (line 20) | class UnidirectionalRNNEncoderTest(tf.test.TestCase):
    method test_trainable_variables (line 24) | def test_trainable_variables(self):
    method test_encode (line 64) | def test_encode(self):
    method test_encode_with_embedder (line 113) | def test_encode_with_embedder(self):
  class BidirectionalRNNEncoderTest (line 129) | class BidirectionalRNNEncoderTest(tf.test.TestCase):
    method test_trainable_variables (line 133) | def test_trainable_variables(self):
    method test_encode (line 178) | def test_encode(self):

FILE: texar_repo/texar/modules/encoders/transformer_encoders.py
  function default_transformer_poswise_net_hparams (line 42) | def default_transformer_poswise_net_hparams(output_dim=512):
  class TransformerEncoder (line 114) | class TransformerEncoder(EncoderBase):
    method __init__ (line 128) | def __init__(self, hparams=None):
    method default_hparams (line 176) | def default_hparams():
    method _build (line 292) | def _build(self, inputs, sequence_length, mode=None):

FILE: texar_repo/texar/modules/memory/embed_fns.py
  function default_memnet_embed_fn_hparams (line 29) | def default_memnet_embed_fn_hparams():

FILE: texar_repo/texar/modules/memory/memory_network.py
  class MemNetSingleLayer (line 38) | class MemNetSingleLayer(ModuleBase):
    method __init__ (line 49) | def __init__(self, H=None, hparams=None):
    method default_hparams (line 55) | def default_hparams():
    method _build (line 73) | def _build(self, u, m, c, **kwargs):
  class MemNetBase (line 108) | class MemNetBase(ModuleBase):
    method __init__ (line 150) | def __init__(self,
    method _build_embed_fn (line 173) | def _build_embed_fn(self, input_embed_fn, output_embed_fn, query_embed...
    method get_default_embed_fn (line 207) | def get_default_embed_fn(self, memory_size, embed_fn_hparams):
    method default_hparams (line 303) | def default_hparams():
    method _build (line 376) | def _build(self, memory, query, **kwargs):
    method memory_size (line 380) | def memory_size(self):
    method raw_memory_dim (line 386) | def raw_memory_dim(self):
    method memory_dim (line 392) | def memory_dim(self):
  class MemNetRNNLike (line 398) | class MemNetRNNLike(MemNetBase):
    method __init__ (line 445) | def __init__(self,
    method default_hparams (line 465) | def default_hparams():
    method _build (line 530) | def _build(self, memory=None, query=None, soft_memory=None, soft_query...

FILE: texar_repo/texar/modules/memory/memory_network_test.py
  class MemNetRNNLikeTest (line 17) | class MemNetRNNLikeTest(tf.test.TestCase):
    method _test_memory_dim (line 21) | def _test_memory_dim(self, combine_mode='add', soft_memory=False,
    method test_memory_dim (line 87) | def test_memory_dim(self):

FILE: texar_repo/texar/modules/networks/conv_networks.py
  function _to_list (line 38) | def _to_list(value, name=None, list_length=None):
  class Conv1DNetwork (line 56) | class Conv1DNetwork(FeedForwardNetworkBase):
    method __init__ (line 88) | def __init__(self, hparams=None):
    method default_hparams (line 96) | def default_hparams():
    method _build_pool_hparams (line 301) | def _build_pool_hparams(self):
    method _build_conv1d_hparams (line 329) | def _build_conv1d_hparams(self, pool_hparams):
    method _build_dense_hparams (line 388) | def _build_dense_hparams(self):
    method _build_layer_hparams (line 417) | def _build_layer_hparams(self):
    method _build (line 453) | def _build(self,    # pylint: disable=arguments-differ

FILE: texar_repo/texar/modules/networks/conv_networks_test.py
  class Conv1DNetworkTest (line 17) | class Conv1DNetworkTest(tf.test.TestCase):
    method test_feedforward (line 21) | def test_feedforward(self):
    method test_unknown_seq_length (line 66) | def test_unknown_seq_length(self):
    method test_mask_input (line 115) | def test_mask_input(self):

FILE: texar_repo/texar/modules/networks/network_base.py
  function _build_layers (line 38) | def _build_layers(network, layers=None, layer_hparams=None):
  class FeedForwardNetworkBase (line 68) | class FeedForwardNetworkBase(ModuleBase):
    method __init__ (line 80) | def __init__(self, hparams=None):
    method default_hparams (line 90) | def default_hparams():
    method _build (line 103) | def _build(self, inputs, mode=None):
    method append_layer (line 141) | def append_layer(self, layer):
    method has_layer (line 162) | def has_layer(self, layer_name):
    method layer_by_name (line 171) | def layer_by_name(self, layer_name):
    method layers_by_name (line 181) | def layers_by_name(self):
    method layers (line 187) | def layers(self):
    method layer_names (line 193) | def layer_names(self):
    method layer_outputs_by_name (line 198) | def layer_outputs_by_name(self, layer_name):
    method layer_outputs (line 208) | def layer_outputs(self):

FILE: texar_repo/texar/modules/networks/networks.py
  class FeedForwardNetwork (line 31) | class FeedForwardNetwork(FeedForwardNetworkBase):
    method __init__ (line 63) | def __init__(self, layers=None, hparams=None):
    method default_hparams (line 71) | def default_hparams():

FILE: texar_repo/texar/modules/networks/networks_test.py
  class FeedForwardNetworkTest (line 15) | class FeedForwardNetworkTest(tf.test.TestCase):
    method test_feedforward (line 20) | def test_feedforward(self):

FILE: texar_repo/texar/modules/policies/policy_nets.py
  class PolicyNetBase (line 37) | class PolicyNetBase(ModuleBase):
    method __init__ (line 56) | def __init__(self,
    method default_hparams (line 66) | def default_hparams():
    method _build_network (line 133) | def _build_network(self, network, kwargs):
    method _build (line 144) | def _build(self, inputs, mode=None): # pylint: disable=arguments-differ
    method network (line 148) | def network(self):
  class CategoricalPolicyNet (line 155) | class CategoricalPolicyNet(PolicyNetBase):
    method __init__ (line 184) | def __init__(self,
    method default_hparams (line 199) | def default_hparams():
    method _append_output_layer (line 263) | def _append_output_layer(self):
    method _build (line 278) | def _build(self, inputs, mode=None):
    method action_space (line 327) | def action_space(self):

FILE: texar_repo/texar/modules/policies/policy_nets_test.py
  class CategoricalPolicyNetTest (line 15) | class CategoricalPolicyNetTest(tf.test.TestCase):
    method test_categorical_policy (line 19) | def test_categorical_policy(self):

FILE: texar_repo/texar/modules/qnets/qnets.py
  class QNetBase (line 35) | class QNetBase(ModuleBase):
    method __init__ (line 55) | def __init__(self,
    method default_hparams (line 65) | def default_hparams():
    method _build_network (line 126) | def _build_network(self, network, kwargs):
    method _build (line 137) | def _build(self, inputs, mode=None): # pylint: disable=arguments-differ
    method network (line 141) | def network(self):
  class CategoricalQNet (line 147) | class CategoricalQNet(QNetBase):
    method __init__ (line 172) | def __init__(self,
    method default_hparams (line 187) | def default_hparams():
    method _append_output_layer (line 232) | def _append_output_layer(self):
    method _build (line 246) | def _build(self, inputs, mode=None):
    method action_space (line 277) | def action_space(self):

FILE: texar_repo/texar/run/executor.py
  class Executor (line 31) | class Executor(object):
    method __init__ (line 75) | def __init__(self,
    method _get_train_spec (line 97) | def _get_train_spec(self, max_steps=None):
    method _get_eval_spec (line 109) | def _get_eval_spec(self, steps):
    method train (line 121) | def train(self, max_steps=None):
    method evaluate (line 137) | def evaluate(self, steps=None, checkpoint_path=None):
    method train_and_evaluate (line 158) | def train_and_evaluate(self, max_train_steps=None, eval_steps=None):

FILE: texar_repo/texar/run/executor_test.py
  class ExecutorTest (line 20) | class ExecutorTest(tf.test.TestCase):
    method setUp (line 24) | def setUp(self):
    method test_execute_seq2seq (line 60) | def test_execute_seq2seq(self):

FILE: texar_repo/texar/utils/average_recorder.py
  class _SingleAverageRecorder (line 31) | class _SingleAverageRecorder(object):
    method __init__ (line 41) | def __init__(self, size=None, name=None):
    method add (line 51) | def add(self, record, weight=None):
    method avg (line 80) | def avg(self):
    method reset (line 87) | def reset(self):
    method to_str (line 95) | def to_str(self, precision=None):
    method name (line 119) | def name(self):
  class AverageRecorder (line 124) | class AverageRecorder(object):
    method __init__ (line 160) | def __init__(self, size=None):
    method _to_dict (line 168) | def _to_dict(self, record):
    method add (line 177) | def add(self, record, weight=None):
    method avg (line 228) | def avg(self, id_or_name=None):
    method reset (line 267) | def reset(self, id_or_name=None):
    method to_str (line 285) | def to_str(self, precision=None, delimiter=' '):

FILE: texar_repo/texar/utils/average_recorder_test.py
  class AverageRecorderTest (line 14) | class AverageRecorderTest(tf.test.TestCase):
    method test_single_average_recoder (line 18) | def test_single_average_recoder(self):
    method test_average_recorder (line 49) | def test_average_recorder(self):

FILE: texar_repo/texar/utils/beam_search.py
  function _merge_beam_dim (line 35) | def _merge_beam_dim(tensor):
  function _unmerge_beam_dim (line 50) | def _unmerge_beam_dim(tensor, batch_size, beam_size):
  function _expand_to_beam_size (line 66) | def _expand_to_beam_size(tensor, beam_size):
  function get_state_shape_invariants (line 83) | def get_state_shape_invariants(tensor):
  function log_prob_from_logits (line 91) | def log_prob_from_logits(logits):
  function compute_batch_indices (line 95) | def compute_batch_indices(batch_size, beam_size):
  function compute_topk_scores_and_seq (line 114) | def compute_topk_scores_and_seq(sequences, scores, scores_to_gather, flags,
  function beam_search (line 186) | def beam_search(symbols_to_logits_fn,

FILE: texar_repo/texar/utils/dtypes.py
  function get_tf_dtype (line 39) | def get_tf_dtype(dtype): # pylint: disable=too-many-return-statements
  function is_callable (line 75) | def is_callable(x):
  function is_str (line 84) | def is_str(x):
  function is_placeholder (line 90) | def is_placeholder(x):
  function maybe_hparams_to_dict (line 99) | def maybe_hparams_to_dict(hparams):
  function _maybe_list_to_array (line 110) | def _maybe_list_to_array(str_list, dtype_as):
  function compat_as_text (line 118) | def compat_as_text(str_):

FILE: texar_repo/texar/utils/exceptions.py
  class TexarError (line 27) | class TexarError(Exception):

FILE: texar_repo/texar/utils/mode.py
  function maybe_global_mode (line 37) | def maybe_global_mode(mode):
  function is_train_mode (line 46) | def is_train_mode(mode):
  function is_eval_mode (line 56) | def is_eval_mode(mode):
  function is_predict_mode (line 66) | def is_predict_mode(mode):
  function is_train_mode_py (line 76) | def is_train_mode_py(mode, default=True):
  function is_eval_mode_py (line 95) | def is_eval_mode_py(mode, default=False):
  function is_predict_mode_py (line 114) | def is_predict_mode_py(mode, default=False):
  function switch_dropout (line 133) | def switch_dropout(dropout_keep_prob, mode=None):

FILE: texar_repo/texar/utils/mode_test.py
  class UtilsTest (line 16) | class UtilsTest(tf.test.TestCase):
    method test_mode (line 20) | def test_mode(self):

FILE: texar_repo/texar/utils/shapes.py
  function transpose_batch_time (line 44) | def transpose_batch_time(inputs):
  function get_batch_size (line 62) | def get_batch_size(tensor):
  function get_rank (line 69) | def get_rank(tensor):
  function mask_sequences (line 91) | def mask_sequences(sequence,
  function _mask_sequences_tensor (line 138) | def _mask_sequences_tensor(sequence,
  function _mask_sequences_py (line 191) | def _mask_sequences_py(sequence,
  function flatten (line 248) | def flatten(tensor, preserve_dims, flattened_dim=None):
  function shape_list (line 276) | def shape_list(x):
  function pad_and_concat (line 301) | def pad_and_concat(values, axis, rank=None, pad_axis=None,

FILE: texar_repo/texar/utils/shapes_test.py
  class ShapesTest (line 17) | class ShapesTest(tf.test.TestCase):
    method test_mask_sequences (line 21) | def test_mask_sequences(self):
    method test_pad_and_concat (line 32) | def test_pad_and_concat(self):

FILE: texar_repo/texar/utils/transformer_attentions.py
  function attention_bias_lower_triangle (line 36) | def attention_bias_lower_triangle(length, bias_value=-1e18):
  function attention_bias_local (line 48) | def attention_bias_local(length, max_backward, max_forward, bias_value=-...
  function attention_bias_ignore_padding (line 74) | def attention_bias_ignore_padding(memory_padding, bias_value=-1e18):
  function _ones_matrix_band_part (line 88) | def _ones_matrix_band_part(rows, cols, num_lower, num_upper,

FILE: texar_repo/texar/utils/transformer_utils.py
  class PadRemover (line 30) | class PadRemover(object):
    method __init__ (line 52) | def __init__(self, pad_mask):
    method remove (line 74) | def remove(self, x):
    method restore (line 96) | def restore(self, x):
  function embedding_to_padding (line 115) | def embedding_to_padding(emb):
  function smoothing_cross_entropy (line 129) | def smoothing_cross_entropy(logits,

FILE: texar_repo/texar/utils/utils.py
  function _expand_name (line 81) | def _expand_name(name):
  function _inspect_getargspec (line 89) | def _inspect_getargspec(fn):
  function get_args (line 98) | def get_args(fn):
  function get_default_arg_values (line 118) | def get_default_arg_values(fn):
  function check_or_get_class (line 137) | def check_or_get_class(class_or_name, module_path=None, superclass=None):
  function get_class (line 168) | def get_class(class_name, module_paths=None):
  function check_or_get_instance (line 206) | def check_or_get_instance(ins_or_class_or_name, kwargs, module_paths=None,
  function get_instance (line 244) | def get_instance(class_or_name, kwargs, module_paths=None):
  function check_or_get_instance_with_redundant_kwargs (line 283) | def check_or_get_instance_with_redundant_kwargs(
  function get_instance_with_redundant_kwargs (line 323) | def get_instance_with_redundant_kwargs(
  function get_function (line 360) | def get_function(fn_or_name, module_paths=None):
  function call_function_with_redundant_kwargs (line 396) | def call_function_with_redundant_kwargs(fn, kwargs):
  function get_instance_kwargs (line 428) | def get_instance_kwargs(kwargs, hparams):
  function dict_patch (line 454) | def dict_patch(tgt_dict, src_dict):
  function dict_lookup (line 478) | def dict_lookup(dict_, keys, default=None):
  function dict_fetch (line 498) | def dict_fetch(src_dict, tgt_dict_or_keys):
  function dict_pop (line 526) | def dict_pop(dict_, pop_keys, default=None):
  function flatten_dict (line 544) | def flatten_dict(dict_, parent_key="", sep="."):
  function default_str (line 573) | def default_str(str_, default_str):
  function uniquify_str (line 589) | def uniquify_str(str_, str_set):
  function _recur_split (line 623) | def _recur_split(s, dtype_as):
  function strip_token (line 633) | def strip_token(str_, token, is_token_list=False, compat=True):
  function strip_eos (line 694) | def strip_eos(str_, eos_token='<EOS>', is_token_list=False, compat=True):
  function strip_bos (line 741) | def strip_bos(str_, bos_token='<BOS>', is_token_list=False, compat=True):
  function strip_special_tokens (line 790) | def strip_special_tokens(str_, strip_pad='<PAD>', strip_bos='<BOS>',
  function str_join (line 853) | def str_join(tokens, sep=' ', compat=True):
  function map_ids_to_strs (line 882) | def map_ids_to_strs(ids, vocab, join=True, strip_pad='<PAD>',
  function ceildiv (line 946) | def ceildiv(a, b):
  function straight_through (line 960) | def straight_through(fw_tensor, bw_tensor):

FILE: texar_repo/texar/utils/utils_io.py
  function _load_config_python (line 65) | def _load_config_python(fname):
  function _load_config_yaml (line 75) | def _load_config_yaml(fname):
  function load_config_single (line 80) | def load_config_single(fname, config=None):
  function load_config (line 114) | def load_config(config_path, config=None):
  function write_paired_text (line 155) | def write_paired_text(src, tgt, fname, append=False, mode='h', sep='\t',
  function maybe_create_dir (line 223) | def maybe_create_dir(dirname):
  function get_files (line 232) | def get_files(file_paths):

FILE: texar_repo/texar/utils/utils_test.py
  class UtilsTest (line 21) | class UtilsTest(tf.test.TestCase):
    method test_dict_patch (line 25) | def test_dict_patch(self):
    method test_strip_token (line 51) | def test_strip_token(self):
    method test_strip_bos (line 74) | def test_strip_bos(self):
    method test_strip_eos (line 88) | def test_strip_eos(self):
    method test_strip_special_tokens (line 101) | def test_strip_special_tokens(self):
    method test_str_join (line 114) | def test_str_join(self):
    method test_uniquify_str (line 133) | def test_uniquify_str(self):
    method test_map_ids_to_strs (line 145) | def test_map_ids_to_strs(self):

FILE: texar_repo/texar/utils/variables.py
  function get_unique_named_variable_scope (line 33) | def get_unique_named_variable_scope(base_name):
  function add_variable (line 53) | def add_variable(variable, var_list):
  function collect_trainable_variables (line 67) | def collect_trainable_variables(modules):