SYMBOL INDEX (2653 symbols across 280 files)

FILE: packages/fairseq-hacked/eval_lm.py
  class WordStat (line 20) | class WordStat(object):
    method __init__ (line 21) | def __init__(self, word, is_bpe):
    method add (line 29) | def add(self, log_prob, next_word_prob):
    method __str__ (line 41) | def __str__(self):
  function main (line 52) | def main(parsed_args):
  function cli_main (line 247) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank.py
  function score_target_hypo (line 14) | def score_target_hypo(
  function match_target_hypo (line 153) | def match_target_hypo(args, target_outfile, hypo_outfile):
  function load_score_files (line 215) | def load_score_files(args):
  function rerank (line 347) | def rerank(args):
  function cli_main (line 406) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_generate.py
  function gen_and_reprocess_nbest (line 22) | def gen_and_reprocess_nbest(args):
  function cli_main (line 391) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_options.py
  function get_reranking_parser (line 9) | def get_reranking_parser(default_task='translation'):
  function get_tuning_parser (line 15) | def get_tuning_parser(default_task='translation'):
  function add_reranking_args (line 22) | def add_reranking_args(parser):
  function add_tuning_args (line 110) | def add_tuning_args(parser):

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_score_bw.py
  function score_bw (line 9) | def score_bw(args):
  function cli_main (line 130) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_score_lm.py
  function score_lm (line 7) | def score_lm(args):
  function cli_main (line 68) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_tune.py
  function random_search (line 9) | def random_search(args):
  function cli_main (line 88) | def cli_main():

FILE: packages/fairseq-hacked/examples/noisychannel/rerank_utils.py
  function reprocess (line 11) | def reprocess(fle):
  function reprocess_nbest (line 70) | def reprocess_nbest(fle):
  function write_reprocessed (line 119) | def write_reprocessed(
  function calc_length_from_frac (line 191) | def calc_length_from_frac(bpe_sentence, prefix_frac, bpe_symbol):
  function get_prefix (line 202) | def get_prefix(sentence, prefix_len):
  function get_prefix_no_bpe (line 211) | def get_prefix_no_bpe(sentence, bpe_symbol, prefix_len):
  function get_prefix_from_len (line 218) | def get_prefix_from_len(sentence, bpe_symbol, prefix_len):
  function get_num_bpe_tokens_from_len (line 229) | def get_num_bpe_tokens_from_len(sentence, bpe_symbol, prefix_len):
  function make_right_to_left (line 236) | def make_right_to_left(line):
  function remove_bpe (line 243) | def remove_bpe(line, bpe_symbol):
  function remove_bpe_dict (line 249) | def remove_bpe_dict(pred_dict, bpe_symbol):
  function parse_bleu_scoring (line 260) | def parse_bleu_scoring(line):
  function get_full_from_prefix (line 267) | def get_full_from_prefix(hypo_prefix, hypos):
  function get_score (line 278) | def get_score(
  class BitextOutput (line 320) | class BitextOutput(object):
    method __init__ (line 321) | def __init__(
  class BitextOutputFromGen (line 406) | class BitextOutputFromGen(object):
    method __init__ (line 407) | def __init__(
  function get_score_from_pos (line 477) | def get_score_from_pos(
  class LMOutput (line 505) | class LMOutput(object):
    method __init__ (line 506) | def __init__(
  function parse_lm (line 535) | def parse_lm(input_file, prefix_len=None, bpe_symbol=None, target_prefix...
  function get_directories (line 580) | def get_directories(
  function lm_scoring (line 647) | def lm_scoring(
  function rescore_file_name (line 824) | def rescore_file_name(

FILE: packages/fairseq-hacked/examples/roberta/commonsense_qa/commonsense_qa_task.py
  class CommonsenseQATask (line 29) | class CommonsenseQATask(FairseqTask):
    method add_args (line 33) | def add_args(parser):
    method __init__ (line 46) | def __init__(self, args, vocab):
    method load_dictionary (line 54) | def load_dictionary(cls, filename):
    method setup_task (line 65) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 76) | def load_dataset(
    method build_model (line 170) | def build_model(self, args):
    method source_dictionary (line 182) | def source_dictionary(self):
    method target_dictionary (line 186) | def target_dictionary(self):

FILE: packages/fairseq-hacked/examples/roberta/multiprocessing_bpe_encoder.py
  function main (line 18) | def main():
  class MultiprocessingEncoder (line 81) | class MultiprocessingEncoder(object):
    method __init__ (line 82) | def __init__(self, args):
    method initializer (line 85) | def initializer(self):
    method encode (line 89) | def encode(self, line):
    method decode (line 94) | def decode(self, tokens):
    method encode_lines (line 98) | def encode_lines(self, lines):
    method decode_lines (line 111) | def decode_lines(self, lines):

FILE: packages/fairseq-hacked/examples/roberta/preprocess_RACE.py
  class InputExample (line 14) | class InputExample:
    method __init__ (line 15) | def __init__(self, paragraph, qa_list, label):
  function get_examples (line 21) | def get_examples(data_dir, set_type):
  function main (line 60) | def main():

FILE: packages/fairseq-hacked/examples/roberta/wsc/wsc_criterion.py
  class WSCCriterion (line 17) | class WSCCriterion(FairseqCriterion):
    method __init__ (line 18) | def __init__(self, args, task):
    method __del__ (line 27) | def __del__(self):
    method add_args (line 32) | def add_args(parser):
    method get_masked_input (line 45) | def get_masked_input(self, tokens, mask):
    method get_lprobs (line 50) | def get_lprobs(self, model, tokens, mask):
    method get_loss (line 58) | def get_loss(self, query_lprobs, cand_lprobs):
    method forward (line 71) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 117) | def aggregate_logging_outputs(logging_outputs):
  class WinograndeCriterion (line 140) | class WinograndeCriterion(WSCCriterion):
    method forward (line 141) | def forward(self, model, sample, reduce=True):

FILE: packages/fairseq-hacked/examples/roberta/wsc/wsc_task.py
  class WSCTask (line 33) | class WSCTask(FairseqTask):
    method add_args (line 37) | def add_args(parser):
    method __init__ (line 49) | def __init__(self, args, vocab):
    method load_dictionary (line 66) | def load_dictionary(cls, filename):
    method setup_task (line 77) | def setup_task(cls, args, **kwargs):
    method binarize (line 86) | def binarize(self, s: str, append_eos: bool = False):
    method binarize_with_mask (line 98) | def binarize_with_mask(self, txt, prefix, suffix, leading_space, trail...
    method load_dataset (line 108) | def load_dataset(
    method build_dataset_for_inference (line 216) | def build_dataset_for_inference(self, sample_json):
    method disambiguate_pronoun (line 224) | def disambiguate_pronoun(self, model, sentence, use_cuda=False):
    method source_dictionary (line 261) | def source_dictionary(self):
    method target_dictionary (line 265) | def target_dictionary(self):
  class WinograndeTask (line 270) | class WinograndeTask(WSCTask):
    method setup_task (line 277) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 286) | def load_dataset(

FILE: packages/fairseq-hacked/examples/roberta/wsc/wsc_utils.py
  function convert_sentence_to_json (line 10) | def convert_sentence_to_json(sentence):
  function extended_noun_chunks (line 36) | def extended_noun_chunks(sentence):
  function find_token (line 52) | def find_token(sentence, start_pos):
  function find_span (line 61) | def find_span(sentence, search_text, start=0):
  function get_detokenizer (line 77) | def get_detokenizer():
  function get_spacy_nlp (line 85) | def get_spacy_nlp():
  function jsonl_iterator (line 92) | def jsonl_iterator(input_fname, positive_only=False, ngram_order=3, eval...
  function winogrande_jsonl_iterator (line 195) | def winogrande_jsonl_iterator(input_fname, eval=False):
  function filter_noun_chunks (line 215) | def filter_noun_chunks(

FILE: packages/fairseq-hacked/examples/speech_recognition/criterions/ASG_loss.py
  class ASGCriterion (line 20) | class ASGCriterion(FairseqCriterion):
    method add_args (line 22) | def add_args(parser):
    method __init__ (line 45) | def __init__(self, args, task):
    method linseg_step (line 68) | def linseg_step(self):
    method replace_eos_with_silence (line 82) | def replace_eos_with_silence(self, tgt):
    method forward (line 90) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 142) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/examples/speech_recognition/criterions/CTC_loss.py
  function arr_to_toks (line 24) | def arr_to_toks(arr):
  function compute_ctc_uer (line 31) | def compute_ctc_uer(logprobs, targets, input_lengths, target_lengths, bl...
  class CTCCriterion (line 78) | class CTCCriterion(FairseqCriterion):
    method __init__ (line 79) | def __init__(self, args, task):
    method add_args (line 86) | def add_args(parser):
    method forward (line 98) | def forward(self, model, sample, reduce=True, log_probs=True):
    method aggregate_logging_outputs (line 175) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/examples/speech_recognition/criterions/cross_entropy_acc.py
  class CrossEntropyWithAccCriterion (line 18) | class CrossEntropyWithAccCriterion(FairseqCriterion):
    method __init__ (line 19) | def __init__(self, args, task):
    method compute_loss (line 22) | def compute_loss(self, model, net_output, target, reduction, log_probs):
    method get_logging_output (line 45) | def get_logging_output(self, sample, target, lprobs, loss):
    method forward (line 68) | def forward(self, model, sample, reduction="sum", log_probs=True):
    method aggregate_logging_outputs (line 102) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/examples/speech_recognition/datasets/asr_prep_json.py
  function process_sample (line 24) | def process_sample(aud_path, lable, utt_id, sp, tgt_dict):
  function main (line 41) | def main():

FILE: packages/fairseq-hacked/examples/speech_recognition/infer.py
  function add_asr_eval_argument (line 26) | def add_asr_eval_argument(parser):
  function check_args (line 59) | def check_args(args):
  function get_dataset_itr (line 70) | def get_dataset_itr(args, task):
  function process_predictions (line 84) | def process_predictions(
  function prepare_result_files (line 106) | def prepare_result_files(args):
  function load_models_and_criterions (line 124) | def load_models_and_criterions(filenames, arg_overrides=None, task=None):
  function optimize_models (line 148) | def optimize_models(args, use_cuda, models):
  function main (line 162) | def main(args):
  function cli_main (line 260) | def cli_main():

FILE: packages/fairseq-hacked/examples/speech_recognition/models/vggtransformer.py
  class VGGTransformerModel (line 27) | class VGGTransformerModel(FairseqEncoderDecoderModel):
    method __init__ (line 33) | def __init__(self, encoder, decoder):
    method add_args (line 37) | def add_args(parser):
    method build_encoder (line 120) | def build_encoder(cls, args, task):
    method build_decoder (line 130) | def build_decoder(cls, args, task):
    method build_model (line 140) | def build_model(cls, args, task):
    method get_normalized_probs (line 150) | def get_normalized_probs(self, net_output, log_probs, sample=None):
  function prepare_transformer_encoder_params (line 172) | def prepare_transformer_encoder_params(
  function prepare_transformer_decoder_params (line 192) | def prepare_transformer_decoder_params(
  class VGGTransformerEncoder (line 212) | class VGGTransformerEncoder(FairseqEncoder):
    method __init__ (line 215) | def __init__(
    method forward (line 321) | def forward(self, src_tokens, src_lengths, **kwargs):
    method infer_conv_output_dim (line 383) | def infer_conv_output_dim(self, in_channels, input_dim):
    method validate_transformer_config (line 393) | def validate_transformer_config(self, transformer_config):
    method parse_transformer_context (line 404) | def parse_transformer_context(self, transformer_context):
    method parse_transformer_sampling (line 438) | def parse_transformer_sampling(self, transformer_sampling, num_layers):
    method slice (line 476) | def slice(self, embedding, padding_mask, attn_mask, sampling_factor):
    method lengths_to_attn_mask (line 490) | def lengths_to_attn_mask(self, input_lengths, subsampling_factor=1):
    method reorder_encoder_out (line 542) | def reorder_encoder_out(self, encoder_out, new_order):
  class TransformerDecoder (line 553) | class TransformerDecoder(FairseqIncrementalDecoder):
    method __init__ (line 567) | def __init__(
    method forward (line 621) | def forward(self, prev_output_tokens, encoder_out=None, incremental_st...
    method buffered_future_mask (line 692) | def buffered_future_mask(self, tensor):
    method _transpose_if_training (line 708) | def _transpose_if_training(self, x, incremental_state):
    method _transpose_if_inference (line 713) | def _transpose_if_inference(self, x, incremental_state):
  class VGGTransformerEncoderModel (line 720) | class VGGTransformerEncoderModel(FairseqEncoderModel):
    method __init__ (line 721) | def __init__(self, encoder):
    method add_args (line 725) | def add_args(parser):
    method build_model (line 786) | def build_model(cls, args, task):
    method get_normalized_probs (line 801) | def get_normalized_probs(self, net_output, log_probs, sample=None):
  class VGGTransformerEncoderOnly (line 811) | class VGGTransformerEncoderOnly(VGGTransformerEncoder):
    method __init__ (line 812) | def __init__(
    method forward (line 834) | def forward(self, src_tokens, src_lengths, **kwargs):
    method max_positions (line 850) | def max_positions(self):
  function Embedding (line 855) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function Linear (line 862) | def Linear(in_features, out_features, bias=True, dropout=0):
  function LinearizedConv1d (line 871) | def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0, ...
  function LayerNorm (line 880) | def LayerNorm(embedding_dim):
  function base_architecture (line 886) | def base_architecture(args):
  function vggtransformer_1 (line 905) | def vggtransformer_1(args):
  function vggtransformer_2 (line 926) | def vggtransformer_2(args):
  function vggtransformer_base (line 947) | def vggtransformer_base(args):
  function base_architecture_enconly (line 984) | def base_architecture_enconly(args):
  function vggtransformer_enc_1 (line 999) | def vggtransformer_enc_1(args):

FILE: packages/fairseq-hacked/examples/speech_recognition/models/w2l_conv_glu_enc.py
  class W2lConvGluEncoderModel (line 43) | class W2lConvGluEncoderModel(FairseqEncoderModel):
    method __init__ (line 44) | def __init__(self, encoder):
    method add_args (line 48) | def add_args(parser):
    method build_model (line 73) | def build_model(cls, args, task):
    method get_normalized_probs (line 84) | def get_normalized_probs(self, net_output, log_probs, sample=None):
  class W2lConvGluEncoder (line 90) | class W2lConvGluEncoder(FairseqEncoder):
    method __init__ (line 91) | def __init__(
    method forward (line 120) | def forward(self, src_tokens, src_lengths, **kwargs):
    method reorder_encoder_out (line 156) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 165) | def max_positions(self):
  function w2l_conv_glu_enc (line 171) | def w2l_conv_glu_enc(args):

FILE: packages/fairseq-hacked/examples/speech_recognition/tasks/speech_recognition.py
  function get_asr_dataset_from_json (line 17) | def get_asr_dataset_from_json(data_json_path, tgt_dict):
  class SpeechRecognitionTask (line 68) | class SpeechRecognitionTask(FairseqTask):
    method add_args (line 74) | def add_args(parser):
    method __init__ (line 81) | def __init__(self, args, tgt_dict):
    method setup_task (line 86) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 102) | def load_dataset(self, split, combine=False, **kwargs):
    method build_generator (line 111) | def build_generator(self, args):
    method target_dictionary (line 125) | def target_dictionary(self):
    method source_dictionary (line 131) | def source_dictionary(self):

FILE: packages/fairseq-hacked/examples/speech_recognition/utils/wer_utils.py
  class Code (line 24) | class Code(Enum):
  class Token (line 31) | class Token(object):
    method __init__ (line 32) | def __init__(self, lbl="", st=np.nan, en=np.nan):
  class AlignmentResult (line 39) | class AlignmentResult(object):
    method __init__ (line 40) | def __init__(self, refs, hyps, codes, score):
  function coordinate_to_offset (line 47) | def coordinate_to_offset(row, col, ncols):
  function offset_to_row (line 51) | def offset_to_row(offset, ncols):
  function offset_to_col (line 55) | def offset_to_col(offset, ncols):
  function trimWhitespace (line 59) | def trimWhitespace(str):
  function str2toks (line 63) | def str2toks(str):
  class EditDistance (line 71) | class EditDistance(object):
    method __init__ (line 72) | def __init__(self, time_mediated):
    method cost (line 80) | def cost(self, ref, hyp, code):
    method get_result (line 98) | def get_result(self, refs, hyps):
    method align (line 141) | def align(self, refs, hyps):
  class WERTransformer (line 205) | class WERTransformer(object):
    method __init__ (line 206) | def __init__(self, hyp_str, ref_str, verbose=True):
    method process (line 221) | def process(self, input):  # std::vector<std::string>&& input
    method report_result (line 294) | def report_result(self):
    method wer (line 320) | def wer(self):
    method stats (line 331) | def stats(self):
  function calc_wer (line 354) | def calc_wer(hyp_str, ref_str):
  function calc_wer_stats (line 359) | def calc_wer_stats(hyp_str, ref_str):
  function get_wer_alignment_codes (line 364) | def get_wer_alignment_codes(hyp_str, ref_str):
  function merge_counts (line 373) | def merge_counts(x, y):

FILE: packages/fairseq-hacked/examples/speech_recognition/w2l_decoder.py
  class W2lDecoder (line 28) | class W2lDecoder(object):
    method __init__ (line 29) | def __init__(self, args, tgt_dict):
    method generate (line 48) | def generate(self, models, sample, prefix_tokens=None):
    method get_emissions (line 58) | def get_emissions(self, models, encoder_input):
    method get_tokens (line 67) | def get_tokens(self, idxs):
  class W2lViterbiDecoder (line 78) | class W2lViterbiDecoder(W2lDecoder):
    method __init__ (line 79) | def __init__(self, args, tgt_dict):
    method decode (line 82) | def decode(self, emissions):
  class W2lKenLMDecoder (line 106) | class W2lKenLMDecoder(W2lDecoder):
    method __init__ (line 107) | def __init__(self, args, tgt_dict):
    method decode (line 149) | def decode(self, emissions):

FILE: packages/fairseq-hacked/examples/translation_moe/score.py
  function main (line 23) | def main():
  function dictolist (line 51) | def dictolist(d):
  function load_sys (line 56) | def load_sys(paths):
  function load_ref (line 77) | def load_ref(path):
  function merge (line 98) | def merge(src, tgt, hypos, log_probs, path):
  function corpus_bleu (line 109) | def corpus_bleu(sys_stream, ref_streams):
  function sentence_bleu (line 114) | def sentence_bleu(hypothesis, reference):
  function pairwise (line 130) | def pairwise(sents):
  function multi_ref (line 141) | def multi_ref(refs, hypos):
  function intra_ref (line 178) | def intra_ref(refs):

FILE: packages/fairseq-hacked/fairseq/binarizer.py
  function safe_readline (line 12) | def safe_readline(f):
  class Binarizer (line 22) | class Binarizer:
    method binarize (line 24) | def binarize(
    method binarize_alignments (line 68) | def binarize_alignments(filename, alignment_parser, consumer, offset=0...
    method find_offsets (line 84) | def find_offsets(filename, num_chunks):

FILE: packages/fairseq-hacked/fairseq/bleu.py
  class BleuStat (line 22) | class BleuStat(ctypes.Structure):
  class SacrebleuScorer (line 37) | class SacrebleuScorer(object):
    method __init__ (line 38) | def __init__(self):
    method reset (line 44) | def reset(self, one_init=False):
    method add_string (line 50) | def add_string(self, ref, pred):
    method score (line 54) | def score(self, order=4):
    method result_string (line 57) | def result_string(self, order=4):
  class Scorer (line 63) | class Scorer(object):
    method __init__ (line 64) | def __init__(self, pad, eos, unk):
    method reset (line 71) | def reset(self, one_init=False):
    method add (line 77) | def add(self, ref, pred):
    method score (line 101) | def score(self, order=4):
    method precision (line 107) | def precision(self):
    method brevity (line 118) | def brevity(self):
    method result_string (line 122) | def result_string(self, order=4):

FILE: packages/fairseq-hacked/fairseq/checkpoint_utils.py
  function save_checkpoint (line 20) | def save_checkpoint(args, trainer, epoch_itr, val_loss):
  function load_checkpoint (line 99) | def load_checkpoint(args, trainer, **passthrough_args):
  function load_checkpoint_to_cpu (line 148) | def load_checkpoint_to_cpu(path, arg_overrides=None):
  function load_model_ensemble (line 170) | def load_model_ensemble(filenames, arg_overrides=None, task=None):
  function load_model_ensemble_and_task (line 183) | def load_model_ensemble_and_task(filenames, arg_overrides=None, task=None):
  function checkpoint_paths (line 203) | def checkpoint_paths(path, pattern=r"checkpoint(\d+)\.pt"):
  function torch_persistent_save (line 222) | def torch_persistent_save(*args, **kwargs):
  function convert_state_dict_type (line 231) | def convert_state_dict_type(state_dict, ttype=torch.FloatTensor):
  function save_state (line 245) | def save_state(
  function _upgrade_state_dict (line 293) | def _upgrade_state_dict(state):
  function prune_state_dict (line 360) | def prune_state_dict(state_dict, args):
  function load_pretrained_component_from_model (line 444) | def load_pretrained_component_from_model(
  function verify_checkpoint_directory (line 475) | def verify_checkpoint_directory(save_dir: str) -> None:

FILE: packages/fairseq-hacked/fairseq/clib/libbleu/libbleu.cpp
  function bleu_ltrim (line 29) | void bleu_ltrim(size_t* len, int** sent, int pad) {
  function bleu_rtrim (line 40) | void bleu_rtrim(size_t* len, int** sent, int pad, int eos) {
  function bleu_trim (line 50) | void bleu_trim(size_t* len, int** sent, int pad, int eos) {
  function bleu_hash (line 55) | size_t bleu_hash(int len, int* data) {
  function bleu_addngram (line 69) | void bleu_addngram(
  function bleu_zero_init (line 101) | void bleu_zero_init(bleu_stat* stat) {
  function bleu_one_init (line 105) | void bleu_one_init(bleu_stat* stat) {
  function bleu_add (line 117) | void bleu_add(

FILE: packages/fairseq-hacked/fairseq/clib/libbleu/module.cpp
  type PyModuleDef (line 16) | struct PyModuleDef

FILE: packages/fairseq-hacked/fairseq/clib/libnat/edit_dist.cpp
  function edit_distance2_with_dp (line 14) | vector<vector<uint32_t>> edit_distance2_with_dp(
  function edit_distance2_backtracking (line 36) | vector<vector<uint32_t>> edit_distance2_backtracking(
  function edit_distance2_backtracking_with_delete (line 107) | vector<vector<uint32_t>> edit_distance2_backtracking_with_delete(
  function compute_ed2 (line 177) | vector<uint32_t> compute_ed2(
  function suggested_ed2_path (line 188) | vector<vector<vector<uint32_t>>> suggested_ed2_path(
  function suggested_ed2_path_with_delete (line 201) | vector<vector<vector<uint32_t>>> suggested_ed2_path_with_delete(
  function PYBIND11_MODULE (line 215) | PYBIND11_MODULE(libnat, m) {

FILE: packages/fairseq-hacked/fairseq/criterions/adaptive_loss.py
  class AdaptiveLoss (line 15) | class AdaptiveLoss(FairseqCriterion):
    method __init__ (line 20) | def __init__(self, args, task):
    method forward (line 30) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 80) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/binary_cross_entropy.py
  class BinaryCrossEntropyCriterion (line 16) | class BinaryCrossEntropyCriterion(FairseqCriterion):
    method __init__ (line 17) | def __init__(self, args, task):
    method forward (line 20) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 56) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/composite_loss.py
  class CompositeLoss (line 13) | class CompositeLoss(FairseqCriterion):
    method add_args (line 18) | def add_args(parser):
    method build_underlying_criterion (line 26) | def build_underlying_criterion(args, task):
    method build_criterion (line 35) | def build_criterion(cls, args, task):

FILE: packages/fairseq-hacked/fairseq/criterions/cross_entropy.py
  class CrossEntropyCriterion (line 15) | class CrossEntropyCriterion(FairseqCriterion):
    method __init__ (line 16) | def __init__(self, args, task):
    method forward (line 19) | def forward(self, model, sample, reduce=True):
    method compute_loss (line 41) | def compute_loss(self, model, net_output, sample, reduce=True):
    method aggregate_logging_outputs (line 54) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/fairseq_criterion.py
  class FairseqCriterion (line 9) | class FairseqCriterion(_Loss):
    method __init__ (line 10) | def __init__(self, args, task):
    method add_args (line 19) | def add_args(parser):
    method build_criterion (line 24) | def build_criterion(cls, args, task):
    method forward (line 27) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 38) | def aggregate_logging_outputs(logging_outputs):
    method grad_denom (line 43) | def grad_denom(sample_sizes):

FILE: packages/fairseq-hacked/fairseq/criterions/label_smoothed_cross_entropy.py
  function label_smoothed_nll_loss (line 13) | def label_smoothed_nll_loss(lprobs, target, epsilon, ignore_index=None, ...
  class LabelSmoothedCrossEntropyCriterion (line 34) | class LabelSmoothedCrossEntropyCriterion(FairseqCriterion):
    method __init__ (line 35) | def __init__(self, args, task):
    method add_args (line 40) | def add_args(parser):
    method forward (line 47) | def forward(self, model, sample, reduce=True):
    method compute_loss (line 69) | def compute_loss(self, model, net_output, sample, reduce=True):
    method aggregate_logging_outputs (line 79) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/label_smoothed_cross_entropy_with_alignment.py
  class LabelSmoothedCrossEntropyCriterionWithAlignment (line 15) | class LabelSmoothedCrossEntropyCriterionWithAlignment(
    method __init__ (line 18) | def __init__(self, args, task):
    method add_args (line 23) | def add_args(parser):
    method forward (line 37) | def forward(self, model, sample, reduce=True):
    method compute_alignment_loss (line 70) | def compute_alignment_loss(self, sample, net_output):
    method aggregate_logging_outputs (line 91) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/legacy_masked_lm.py
  function compute_cross_entropy_loss (line 15) | def compute_cross_entropy_loss(logits, targets, ignore_index=-100):
  class LegacyMaskedLmLoss (line 35) | class LegacyMaskedLmLoss(FairseqCriterion):
    method __init__ (line 52) | def __init__(self, args, task):
    method add_args (line 56) | def add_args(parser):
    method forward (line 72) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 135) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/masked_lm.py
  class MaskedLmLoss (line 17) | class MaskedLmLoss(FairseqCriterion):
    method __init__ (line 22) | def __init__(self, args, task):
    method forward (line 25) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 65) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/nat_loss.py
  class LabelSmoothedDualImitationCriterion (line 17) | class LabelSmoothedDualImitationCriterion(FairseqCriterion):
    method add_args (line 19) | def add_args(parser):
    method _compute_loss (line 30) | def _compute_loss(
    method _custom_loss (line 75) | def _custom_loss(self, loss, name="loss", factor=1.0):
    method forward (line 78) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 143) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/sentence_prediction.py
  class SentencePredictionCriterion (line 17) | class SentencePredictionCriterion(FairseqCriterion):
    method add_args (line 19) | def add_args(parser):
    method forward (line 25) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 70) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/criterions/sentence_ranking.py
  class SentenceRankingCriterion (line 17) | class SentenceRankingCriterion(FairseqCriterion):
    method __init__ (line 18) | def __init__(self, args, task):
    method __del__ (line 25) | def __del__(self):
    method add_args (line 30) | def add_args(parser):
    method forward (line 36) | def forward(self, model, sample, reduce=True):
    method aggregate_logging_outputs (line 88) | def aggregate_logging_outputs(logging_outputs):

FILE: packages/fairseq-hacked/fairseq/distributed_utils.py
  function is_master (line 18) | def is_master(args):
  function infer_init_method (line 22) | def infer_init_method(args):
  function distributed_init (line 74) | def distributed_init(args):
  function suppress_output (line 112) | def suppress_output(is_master):
  function get_rank (line 126) | def get_rank():
  function get_world_size (line 130) | def get_world_size():
  function get_default_group (line 134) | def get_default_group():
  function all_reduce (line 138) | def all_reduce(tensor, group=None):
  function all_gather_list (line 144) | def all_gather_list(data, group=None, max_size=16384):

FILE: packages/fairseq-hacked/fairseq/file_utils.py
  function load_archive_file (line 54) | def load_archive_file(archive_file):
  function url_to_filename (line 95) | def url_to_filename(url, etag=None):
  function filename_to_url (line 113) | def filename_to_url(filename, cache_dir=None):
  function cached_path (line 139) | def cached_path(url_or_filename, cache_dir=None):
  function split_s3_path (line 171) | def split_s3_path(url):
  function s3_request (line 184) | def s3_request(func):
  function s3_etag (line 206) | def s3_etag(url):
  function s3_get (line 217) | def s3_get(url, temp_file):
  function http_get (line 226) | def http_get(url, temp_file):
  function get_from_cache (line 241) | def get_from_cache(url, cache_dir=None):
  function read_set_from_file (line 315) | def read_set_from_file(filename):
  function get_file_extension (line 327) | def get_file_extension(path, dot=True, lower=True):

FILE: packages/fairseq-hacked/fairseq/hub_utils.py
  function from_pretrained (line 18) | def from_pretrained(
  class GeneratorHubInterface (line 77) | class GeneratorHubInterface(nn.Module):
    method __init__ (line 83) | def __init__(self, args, task, models):
    method device (line 113) | def device(self):
    method translate (line 116) | def translate(
    method sample (line 121) | def sample(
    method generate (line 128) | def generate(
    method encode (line 179) | def encode(self, sentence: str) -> torch.LongTensor:
    method decode (line 184) | def decode(self, tokens: torch.LongTensor) -> str:
    method tokenize (line 189) | def tokenize(self, sentence: str) -> str:
    method detokenize (line 194) | def detokenize(self, sentence: str) -> str:
    method apply_bpe (line 199) | def apply_bpe(self, sentence: str) -> str:
    method remove_bpe (line 204) | def remove_bpe(self, sentence: str) -> str:
    method binarize (line 209) | def binarize(self, sentence: str) -> torch.LongTensor:
    method string (line 212) | def string(self, tokens: torch.LongTensor) -> str:
    method _build_sample (line 215) | def _build_sample(self, src_tokens: torch.LongTensor):
  class BPEHubInterface (line 225) | class BPEHubInterface(object):
    method __init__ (line 228) | def __init__(self, bpe, **kwargs):
    method encode (line 234) | def encode(self, sentence: str) -> str:
    method decode (line 237) | def decode(self, sentence: str) -> str:
  class TokenizerHubInterface (line 241) | class TokenizerHubInterface(object):
    method __init__ (line 244) | def __init__(self, tokenizer, **kwargs):
    method encode (line 250) | def encode(self, sentence: str) -> str:
    method decode (line 253) | def decode(self, sentence: str) -> str:

FILE: packages/fairseq-hacked/fairseq/iterative_refinement_generator.py
  class IterativeRefinementGenerator (line 19) | class IterativeRefinementGenerator(object):
    method __init__ (line 20) | def __init__(
    method generate_batched_itr (line 58) | def generate_batched_itr(
    method generate (line 98) | def generate(self, models, sample, prefix_tokens=None):

FILE: packages/fairseq-hacked/fairseq/legacy_distributed_data_parallel.py
  class LegacyDistributedDataParallel (line 27) | class LegacyDistributedDataParallel(nn.Module):
    method __init__ (line 44) | def __init__(self, module, world_size, process_group=None, buffer_size...
    method __getstate__ (line 69) | def __getstate__(self):
    method __setstate__ (line 73) | def __setstate__(self, state):
    method no_sync (line 78) | def no_sync(self):
    method forward (line 85) | def forward(self, *inputs, **kwargs):
    method _register_grad_hook (line 88) | def _register_grad_hook(self):

FILE: packages/fairseq-hacked/fairseq/meters.py
  class AverageMeter (line 9) | class AverageMeter(object):
    method __init__ (line 12) | def __init__(self):
    method reset (line 15) | def reset(self):
    method update (line 21) | def update(self, val, n=1):
  class TimeMeter (line 28) | class TimeMeter(object):
    method __init__ (line 31) | def __init__(self, init=0):
    method reset (line 34) | def reset(self, init=0):
    method update (line 39) | def update(self, val=1):
    method avg (line 43) | def avg(self):
    method elapsed_time (line 47) | def elapsed_time(self):
  class StopwatchMeter (line 51) | class StopwatchMeter(object):
    method __init__ (line 54) | def __init__(self):
    method start (line 57) | def start(self):
    method stop (line 60) | def stop(self, n=1):
    method reset (line 67) | def reset(self):
    method avg (line 73) | def avg(self):

FILE: packages/fairseq-hacked/fairseq/models/__init__.py
  function build_model (line 47) | def build_model(args, task):
  function register_model (line 51) | def register_model(name):
  function register_model_architecture (line 84) | def register_model_architecture(model_name, arch_name):

FILE: packages/fairseq-hacked/fairseq/models/bart/hub_interface.py
  class BARTHubInterface (line 22) | class BARTHubInterface(nn.Module):
    method __init__ (line 28) | def __init__(self, args, task, model):
    method device (line 43) | def device(self):
    method encode (line 46) | def encode(
    method decode (line 78) | def decode(self, tokens: torch.LongTensor):
    method _build_sample (line 93) | def _build_sample(self, src_tokens: List[torch.LongTensor]):
    method sample (line 102) | def sample(
    method generate (line 109) | def generate(
    method extract_features (line 145) | def extract_features(
    method register_classification_head (line 179) | def register_classification_head(
    method predict (line 186) | def predict(self, head: str, tokens: torch.LongTensor, return_logits: ...

FILE: packages/fairseq-hacked/fairseq/models/bart/model.py
  class BARTModel (line 29) | class BARTModel(TransformerModel):
    method hub_models (line 31) | def hub_models(cls):
    method __init__ (line 36) | def __init__(self, args, encoder, decoder):
    method add_args (line 45) | def add_args(parser):
    method supported_targets (line 60) | def supported_targets(self):
    method forward (line 63) | def forward(
    method from_pretrained (line 93) | def from_pretrained(
    method register_classification_head (line 119) | def register_classification_head(
    method upgrade_state_dict_named (line 142) | def upgrade_state_dict_named(self, state_dict, name):
  class BARTClassificationHead (line 216) | class BARTClassificationHead(nn.Module):
    method __init__ (line 219) | def __init__(
    method forward (line 228) | def forward(self, features, **kwargs):
  function bart_large_architecture (line 239) | def bart_large_architecture(args):

FILE: packages/fairseq-hacked/fairseq/models/cmlm_transformer.py
  function _skeptical_unmasking (line 18) | def _skeptical_unmasking(output_scores, output_masks, p):
  class CMLMNATransformerModel (line 28) | class CMLMNATransformerModel(NATransformerModel):
    method add_args (line 30) | def add_args(parser):
    method forward (line 33) | def forward(
    method forward_decoder (line 63) | def forward_decoder(self, decoder_out, encoder_out, decoding_format=No...
  function base_architecture (line 104) | def base_architecture(args):
  function iter_nat_wmt_en_de (line 151) | def iter_nat_wmt_en_de(args):

FILE: packages/fairseq-hacked/fairseq/models/composite_encoder.py
  class CompositeEncoder (line 9) | class CompositeEncoder(FairseqEncoder):
    method __init__ (line 20) | def __init__(self, encoders):
    method forward (line 26) | def forward(self, src_tokens, src_lengths):
    method reorder_encoder_out (line 43) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 51) | def max_positions(self):
    method upgrade_state_dict (line 54) | def upgrade_state_dict(self, state_dict):

FILE: packages/fairseq-hacked/fairseq/models/distributed_fairseq_model.py
  function DistributedFairseqModel (line 14) | def DistributedFairseqModel(args, model):

FILE: packages/fairseq-hacked/fairseq/models/fairseq_decoder.py
  class FairseqDecoder (line 11) | class FairseqDecoder(nn.Module):
    method __init__ (line 14) | def __init__(self, dictionary):
    method forward (line 19) | def forward(self, prev_output_tokens, encoder_out=None, **kwargs):
    method extract_features (line 38) | def extract_features(self, prev_output_tokens, encoder_out=None, **kwa...
    method output_layer (line 47) | def output_layer(self, features, **kwargs):
    method get_normalized_probs (line 56) | def get_normalized_probs(self, net_output, log_probs, sample):
    method max_positions (line 74) | def max_positions(self):
    method upgrade_state_dict (line 78) | def upgrade_state_dict(self, state_dict):
    method prepare_for_onnx_export_ (line 82) | def prepare_for_onnx_export_(self):

FILE: packages/fairseq-hacked/fairseq/models/fairseq_encoder.py
  class FairseqEncoder (line 9) | class FairseqEncoder(nn.Module):
    method __init__ (line 12) | def __init__(self, dictionary):
    method forward (line 16) | def forward(self, src_tokens, src_lengths=None, **kwargs):
    method reorder_encoder_out (line 26) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 39) | def max_positions(self):
    method upgrade_state_dict (line 43) | def upgrade_state_dict(self, state_dict):

FILE: packages/fairseq-hacked/fairseq/models/fairseq_incremental_decoder.py
  class FairseqIncrementalDecoder (line 9) | class FairseqIncrementalDecoder(FairseqDecoder):
    method __init__ (line 31) | def __init__(self, dictionary):
    method forward (line 34) | def forward(
    method extract_features (line 53) | def extract_features(
    method reorder_incremental_state (line 64) | def reorder_incremental_state(self, incremental_state, new_order):
    method set_beam_size (line 84) | def set_beam_size(self, beam_size):

FILE: packages/fairseq-hacked/fairseq/models/fairseq_model.py
  class BaseFairseqModel (line 21) | class BaseFairseqModel(nn.Module):
    method __init__ (line 24) | def __init__(self):
    method add_args (line 29) | def add_args(parser):
    method build_model (line 34) | def build_model(cls, args, task):
    method get_targets (line 38) | def get_targets(self, sample, net_output):
    method get_normalized_probs (line 42) | def get_normalized_probs(self, net_output, log_probs, sample=None):
    method extract_features (line 54) | def extract_features(self, *args, **kwargs):
    method max_positions (line 58) | def max_positions(self):
    method load_state_dict (line 62) | def load_state_dict(self, state_dict, strict=True, args=None):
    method upgrade_state_dict (line 73) | def upgrade_state_dict(self, state_dict):
    method upgrade_state_dict_named (line 77) | def upgrade_state_dict_named(self, state_dict, name):
    method make_generation_fast_ (line 100) | def make_generation_fast_(self, **kwargs):
    method prepare_for_onnx_export_ (line 136) | def prepare_for_onnx_export_(self, **kwargs):
    method from_pretrained (line 152) | def from_pretrained(
    method hub_models (line 193) | def hub_models(cls):
  class FairseqEncoderDecoderModel (line 197) | class FairseqEncoderDecoderModel(BaseFairseqModel):
    method __init__ (line 205) | def __init__(self, encoder, decoder):
    method forward (line 213) | def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs):
    method forward_decoder (line 242) | def forward_decoder(self, prev_output_tokens, **kwargs):
    method extract_features (line 245) | def extract_features(self, src_tokens, src_lengths, prev_output_tokens...
    method output_layer (line 260) | def output_layer(self, features, **kwargs):
    method max_positions (line 264) | def max_positions(self):
    method max_decoder_positions (line 268) | def max_decoder_positions(self):
  class FairseqModel (line 273) | class FairseqModel(FairseqEncoderDecoderModel):
    method __init__ (line 274) | def __init__(self, *args, **kwargs):
  class FairseqMultiModel (line 283) | class FairseqMultiModel(BaseFairseqModel):
    method __init__ (line 286) | def __init__(self, encoders, decoders):
    method build_shared_embeddings (line 299) | def build_shared_embeddings(
    method forward (line 328) | def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs):
    method max_positions (line 337) | def max_positions(self):
    method max_decoder_positions (line 347) | def max_decoder_positions(self):
    method encoder (line 352) | def encoder(self):
    method decoder (line 356) | def decoder(self):
  class FairseqLanguageModel (line 360) | class FairseqLanguageModel(BaseFairseqModel):
    method __init__ (line 367) | def __init__(self, decoder):
    method forward (line 372) | def forward(self, src_tokens, **kwargs):
    method forward_decoder (line 390) | def forward_decoder(self, prev_output_tokens, **kwargs):
    method extract_features (line 393) | def extract_features(self, src_tokens, **kwargs):
    method output_layer (line 404) | def output_layer(self, features, **kwargs):
    method max_positions (line 408) | def max_positions(self):
    method max_decoder_positions (line 412) | def max_decoder_positions(self):
    method supported_targets (line 417) | def supported_targets(self):
  class FairseqEncoderModel (line 421) | class FairseqEncoderModel(BaseFairseqModel):
    method __init__ (line 428) | def __init__(self, encoder):
    method forward (line 433) | def forward(self, src_tokens, src_lengths, **kwargs):
    method get_normalized_probs (line 448) | def get_normalized_probs(self, net_output, log_probs, sample=None):
    method max_positions (line 459) | def max_positions(self):

FILE: packages/fairseq-hacked/fairseq/models/fconv.py
  class FConvModel (line 29) | class FConvModel(FairseqEncoderDecoderModel):
    method hub_models (line 48) | def hub_models(cls):
    method __init__ (line 68) | def __init__(self, encoder, decoder):
    method add_args (line 75) | def add_args(parser):
    method build_model (line 103) | def build_model(cls, args, task):
  class FConvEncoder (line 140) | class FConvEncoder(FairseqEncoder):
    method __init__ (line 158) | def __init__(
    method forward (line 219) | def forward(self, src_tokens, src_lengths):
    method reorder_encoder_out (line 303) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 315) | def max_positions(self):
  class AttentionLayer (line 320) | class AttentionLayer(nn.Module):
    method __init__ (line 321) | def __init__(self, conv_channels, embed_dim, bmm=None):
    method forward (line 330) | def forward(self, x, target_embedding, encoder_out, encoder_padding_ma...
    method make_generation_fast_ (line 368) | def make_generation_fast_(self, beamable_mm_beam_size=None, **kwargs):
  class FConvDecoder (line 375) | class FConvDecoder(FairseqIncrementalDecoder):
    method __init__ (line 378) | def __init__(
    method forward (line 479) | def forward(
    method reorder_incremental_state (line 561) | def reorder_incremental_state(self, incremental_state, new_order):
    method max_positions (line 572) | def max_positions(self):
    method upgrade_state_dict (line 580) | def upgrade_state_dict(self, state_dict):
    method make_generation_fast_ (line 590) | def make_generation_fast_(self, need_attn=False, **kwargs):
    method _embed_tokens (line 593) | def _embed_tokens(self, tokens, incremental_state):
    method _split_encoder_out (line 599) | def _split_encoder_out(self, encoder_out, incremental_state):
    method _transpose_if_training (line 619) | def _transpose_if_training(self, x, incremental_state):
  function extend_conv_spec (line 625) | def extend_conv_spec(convolutions):
  function Embedding (line 646) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function PositionalEmbedding (line 653) | def PositionalEmbedding(num_embeddings, embedding_dim, padding_idx):
  function Linear (line 660) | def Linear(in_features, out_features, dropout=0):
  function LinearizedConv1d (line 668) | def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0, ...
  function ConvTBC (line 677) | def ConvTBC(in_channels, out_channels, kernel_size, dropout=0, **kwargs):
  function base_architecture (line 689) | def base_architecture(args):
  function fconv_iwslt_de_en (line 703) | def fconv_iwslt_de_en(args):
  function fconv_wmt_en_ro (line 713) | def fconv_wmt_en_ro(args):
  function fconv_wmt_en_de (line 719) | def fconv_wmt_en_de(args):
  function fconv_wmt_en_fr (line 733) | def fconv_wmt_en_fr(args):

FILE: packages/fairseq-hacked/fairseq/models/fconv_lm.py
  class FConvLanguageModel (line 16) | class FConvLanguageModel(FairseqLanguageModel):
    method __init__ (line 17) | def __init__(self, decoder):
    method add_args (line 21) | def add_args(parser):
    method build_model (line 64) | def build_model(cls, args, task):
  function base_lm_architecture (line 95) | def base_lm_architecture(args):
  function fconv_lm_dauphin_wikitext103 (line 105) | def fconv_lm_dauphin_wikitext103(args):
  function fconv_lm_dauphin_gbw (line 123) | def fconv_lm_dauphin_gbw(args):

FILE: packages/fairseq-hacked/fairseq/models/fconv_self_att.py
  class FConvModelSelfAtt (line 32) | class FConvModelSelfAtt(FairseqEncoderDecoderModel):
    method hub_models (line 34) | def hub_models(cls):
    method __init__ (line 52) | def __init__(self, encoder, decoder, pretrained_encoder=None):
    method add_args (line 67) | def add_args(parser):
    method build_model (line 107) | def build_model(cls, args, task):
    method pretrained (line 163) | def pretrained(self):
  class FConvEncoder (line 167) | class FConvEncoder(FairseqEncoder):
    method __init__ (line 170) | def __init__(
    method forward (line 224) | def forward(self, src_tokens, src_lengths):
    method reorder_encoder_out (line 280) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 298) | def max_positions(self):
  class FConvDecoder (line 303) | class FConvDecoder(FairseqDecoder):
    method __init__ (line 306) | def __init__(
    method forward (line 445) | def forward(self, prev_output_tokens, encoder_out):
    method max_positions (line 524) | def max_positions(self):
    method make_generation_fast_ (line 528) | def make_generation_fast_(self, need_attn=False, **kwargs):
    method _split_encoder_out (line 531) | def _split_encoder_out(self, encoder_out):
  class SelfAttention (line 541) | class SelfAttention(nn.Module):
    method __init__ (line 542) | def __init__(
    method forward (line 567) | def forward(self, x):
  function Embedding (line 578) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function PositionalEmbedding (line 584) | def PositionalEmbedding(num_embeddings, embedding_dim, padding_idx):
  function Linear (line 590) | def Linear(in_features, out_features, dropout=0.0):
  function LinearizedConv1d (line 598) | def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0.0...
  function ConvTBC (line 607) | def ConvTBC(in_channels, out_channels, kernel_size, dropout=0, **kwargs):
  function base_architecture (line 619) | def base_architecture(args):
  function fconv_self_att_wp (line 642) | def fconv_self_att_wp(args):

FILE: packages/fairseq-hacked/fairseq/models/insertion_transformer.py
  class NegativeDistanceScore (line 20) | class NegativeDistanceScore(object):
    method __init__ (line 21) | def __init__(self):
    method __call__ (line 30) | def __call__(self, i, L, tau):
    method compute_score (line 39) | def compute_score(self, L, tau):
    method compute_score_full (line 44) | def compute_score_full(self, L, tau):
  function _get_ins_targets (line 54) | def _get_ins_targets(in_tokens, out_tokens, padding_idx, unk_idx, vocab_...
  function _apply_ins_words (line 101) | def _apply_ins_words(in_tokens, in_scores, word_ins_pred, word_ins_score...
  class InsertionTransformerModel (line 120) | class InsertionTransformerModel(LevenshteinTransformerModel):
    method __init__ (line 121) | def __init__(self, args, encoder, decoder):
    method add_args (line 125) | def add_args(parser):
    method build_decoder (line 135) | def build_decoder(cls, args, tgt_dict, embed_tokens):
    method forward (line 141) | def forward(
    method forward_decoder (line 174) | def forward_decoder(
  class InsertionTransformerDecoder (line 210) | class InsertionTransformerDecoder(LevenshteinTransformerDecoder):
    method __init__ (line 211) | def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=Fal...
    method forward_word_ins (line 225) | def forward_word_ins(self, prev_output_tokens, encoder_out=None):
    method forward_mask_ins (line 232) | def forward_mask_ins(self, *args, **kwargs):
    method forward_word_del (line 235) | def forward_word_del(self, *args, **kwargs):
    method forward_word_del_mask_ins (line 238) | def forward_word_del_mask_ins(self, *args, **kwargs):
  function base_architecture (line 243) | def base_architecture(args):

FILE: packages/fairseq-hacked/fairseq/models/iterative_nonautoregressive_transformer.py
  function _sequential_poisoning (line 12) | def _sequential_poisoning(s, V, beta=0.33, bos=2, eos=3, pad=1):
  function gumbel_noise (line 46) | def gumbel_noise(input, TINY=1e-8):
  class IterNATransformerModel (line 60) | class IterNATransformerModel(NATransformerModel):
    method add_args (line 62) | def add_args(parser):
    method build_model (line 81) | def build_model(cls, args, task):
    method forward (line 88) | def forward(
  function base_architecture (line 165) | def base_architecture(args):
  function iter_nat_wmt_en_de (line 219) | def iter_nat_wmt_en_de(args):

FILE: packages/fairseq-hacked/fairseq/models/levenshtein_transformer.py
  function _skip (line 23) | def _skip(x, mask):
  function _skip_encoder_out (line 48) | def _skip_encoder_out(encoder, encoder_out, mask):
  function _fill (line 55) | def _fill(x, mask, y, padding_idx):
  function load_libnat (line 86) | def load_libnat():
  function _get_ins_targets (line 97) | def _get_ins_targets(in_tokens, out_tokens, padding_idx, unk_idx):
  function _get_del_targets (line 137) | def _get_del_targets(in_tokens, out_tokens, padding_idx):
  function _get_del_ins_targets (line 165) | def _get_del_ins_targets(in_tokens, out_tokens, padding_idx):
  function _apply_ins_masks (line 203) | def _apply_ins_masks(
  function _apply_ins_words (line 237) | def _apply_ins_words(in_tokens, in_scores, word_ins_pred, word_ins_score...
  function _apply_del_words (line 251) | def _apply_del_words(
  class LevenshteinTransformerModel (line 283) | class LevenshteinTransformerModel(TransformerModel):
    method __init__ (line 284) | def __init__(self, args, encoder, decoder):
    method add_args (line 293) | def add_args(parser):
    method build_decoder (line 328) | def build_decoder(cls, args, tgt_dict, embed_tokens):
    method build_encoder (line 335) | def build_encoder(cls, args, src_dict, embed_tokens):
    method forward (line 341) | def forward(
    method forward_encoder (line 402) | def forward_encoder(self, encoder_inputs):
    method forward_decoder (line 405) | def forward_decoder(
    method initialize_output_tokens (line 517) | def initialize_output_tokens(self, encoder_out, src_tokens):
  class LevenshteinTransformerDecoder (line 535) | class LevenshteinTransformerDecoder(TransformerDecoder):
    method __init__ (line 536) | def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=Fal...
    method extract_features (line 576) | def extract_features(
    method forward_mask_ins (line 642) | def forward_mask_ins(self, prev_output_tokens, encoder_out=None, **unu...
    method forward_word_ins (line 653) | def forward_word_ins(self, prev_output_tokens, encoder_out=None, **unu...
    method forward_word_del (line 663) | def forward_word_del(self, prev_output_tokens, encoder_out=None, **unu...
  function base_architecture (line 675) | def base_architecture(args):
  function levenshtein_transformer_wmt_en_de (line 725) | def levenshtein_transformer_wmt_en_de(args):
  function levenshtein_transformer_vaswani_wmt_en_de_big (line 733) | def levenshtein_transformer_vaswani_wmt_en_de_big(args):
  function levenshtein_transformer_wmt_en_de_big_t2t (line 749) | def levenshtein_transformer_wmt_en_de_big_t2t(args):

FILE: packages/fairseq-hacked/fairseq/models/lightconv.py
  class LightConvModel (line 31) | class LightConvModel(FairseqEncoderDecoderModel):
    method __init__ (line 50) | def __init__(self, encoder, decoder):
    method add_args (line 54) | def add_args(parser):
    method build_model (line 227) | def build_model(cls, args, task):
  class LightConvEncoder (line 283) | class LightConvEncoder(FairseqEncoder):
    method __init__ (line 294) | def __init__(self, args, dictionary, embed_tokens):
    method forward (line 329) | def forward(self, src_tokens, **unused):
    method reorder_encoder_out (line 368) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 389) | def max_positions(self):
  class LightConvDecoder (line 396) | class LightConvDecoder(FairseqIncrementalDecoder):
    method __init__ (line 409) | def __init__(
    method forward (line 481) | def forward(
    method max_positions (line 560) | def max_positions(self):
    method buffered_future_mask (line 566) | def buffered_future_mask(self, tensor):
  class LightConvEncoderLayer (line 583) | class LightConvEncoderLayer(nn.Module):
    method __init__ (line 591) | def __init__(self, args, kernel_size=0):
    method forward (line 637) | def forward(self, x, encoder_padding_mask):
    method maybe_layer_norm (line 671) | def maybe_layer_norm(self, i, x, before=False, after=False):
    method extra_repr (line 678) | def extra_repr(self):
  class LightConvDecoderLayer (line 684) | class LightConvDecoderLayer(nn.Module):
    method __init__ (line 694) | def __init__(self, args, no_encoder_attn=False, kernel_size=0):
    method forward (line 751) | def forward(
    method maybe_layer_norm (line 820) | def maybe_layer_norm(self, layer_norm, x, before=False, after=False):
    method make_generation_fast_ (line 827) | def make_generation_fast_(self, need_attn=False, **kwargs):
    method extra_repr (line 830) | def extra_repr(self):
  function Embedding (line 836) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function Linear (line 843) | def Linear(in_features, out_features, bias=True):
  function base_architecture (line 852) | def base_architecture(args):
  function lightconv_iwslt_de_en (line 917) | def lightconv_iwslt_de_en(args):
  function lightconv_wmt_en_de (line 935) | def lightconv_wmt_en_de(args):
  function lightconv_wmt_en_de_big (line 940) | def lightconv_wmt_en_de_big(args):
  function lightconv_wmt_en_fr_big (line 954) | def lightconv_wmt_en_fr_big(args):
  function lightconv_wmt_zh_en_big (line 960) | def lightconv_wmt_zh_en_big(args):

FILE: packages/fairseq-hacked/fairseq/models/lightconv_lm.py
  class LightConvLanguageModel (line 23) | class LightConvLanguageModel(FairseqLanguageModel):
    method __init__ (line 24) | def __init__(self, decoder):
    method add_args (line 28) | def add_args(parser):
    method build_model (line 208) | def build_model(cls, args, task):
  function base_lm_architecture (line 262) | def base_lm_architecture(args):
  function lightconv_lm_gbw (line 306) | def lightconv_lm_gbw(args):

FILE: packages/fairseq-hacked/fairseq/models/lstm.py
  class LSTMModel (line 22) | class LSTMModel(FairseqEncoderDecoderModel):
    method __init__ (line 23) | def __init__(self, encoder, decoder):
    method add_args (line 27) | def add_args(parser):
    method build_model (line 80) | def build_model(cls, args, task):
  class LSTMEncoder (line 177) | class LSTMEncoder(FairseqEncoder):
    method __init__ (line 180) | def __init__(
    method forward (line 221) | def forward(self, src_tokens, src_lengths):
    method reorder_encoder_out (line 277) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 287) | def max_positions(self):
  class AttentionLayer (line 292) | class AttentionLayer(nn.Module):
    method __init__ (line 293) | def __init__(self, input_embed_dim, source_embed_dim, output_embed_dim...
    method forward (line 301) | def forward(self, input, source_hids, encoder_padding_mask):
  class LSTMDecoder (line 328) | class LSTMDecoder(FairseqIncrementalDecoder):
    method __init__ (line 331) | def __init__(
    method forward (line 396) | def forward(self, prev_output_tokens, encoder_out, incremental_state=N...
    method extract_features (line 402) | def extract_features(self, prev_output_tokens, encoder_out, incrementa...
    method output_layer (line 496) | def output_layer(self, x):
    method reorder_incremental_state (line 505) | def reorder_incremental_state(self, incremental_state, new_order):
    method max_positions (line 521) | def max_positions(self):
    method make_generation_fast_ (line 525) | def make_generation_fast_(self, need_attn=False, **kwargs):
  function Embedding (line 529) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function LSTM (line 536) | def LSTM(input_size, hidden_size, **kwargs):
  function LSTMCell (line 544) | def LSTMCell(input_size, hidden_size, **kwargs):
  function Linear (line 552) | def Linear(in_features, out_features, bias=True, dropout=0):
  function base_architecture (line 562) | def base_architecture(args):
  function lstm_wiseman_iwslt_de_en (line 595) | def lstm_wiseman_iwslt_de_en(args):
  function lstm_luong_wmt_en_de (line 608) | def lstm_luong_wmt_en_de(args):

FILE: packages/fairseq-hacked/fairseq/models/masked_lm.py
  class MaskedLMModel (line 26) | class MaskedLMModel(BaseFairseqModel):
    method __init__ (line 32) | def __init__(self, args, encoder):
    method add_args (line 44) | def add_args(parser):
    method forward (line 149) | def forward(self, src_tokens, segment_labels=None, **kwargs):
    method max_positions (line 152) | def max_positions(self):
    method build_model (line 156) | def build_model(cls, args, task):
  class MaskedLMEncoder (line 171) | class MaskedLMEncoder(FairseqEncoder):
    method __init__ (line 176) | def __init__(self, args, dictionary):
    method forward (line 238) | def forward(self, src_tokens, segment_labels=None, **unused):
    method max_positions (line 294) | def max_positions(self):
    method upgrade_state_dict_named (line 298) | def upgrade_state_dict_named(self, state_dict, name):
  function base_architecture (line 317) | def base_architecture(args):
  function bert_base_architecture (line 349) | def bert_base_architecture(args):
  function bert_large_architecture (line 379) | def bert_large_architecture(args):
  function xlm_architecture (line 388) | def xlm_architecture(args):

FILE: packages/fairseq-hacked/fairseq/models/model_utils.py
  function script_skip_tensor_list (line 13) | def script_skip_tensor_list(x: List[Tensor], mask):
  function script_skip_tensor (line 25) | def script_skip_tensor(x: Tensor, mask):
  function expand_2d_or_3d_tensor (line 37) | def expand_2d_or_3d_tensor(x, trg_dim: int, padding_idx: int):
  function coalesce (line 58) | def coalesce(x: Optional[Tensor], y: Tensor) -> Tensor:
  function fill_tensors (line 63) | def fill_tensors(

FILE: packages/fairseq-hacked/fairseq/models/multilingual_transformer.py
  class MultilingualTransformerModel (line 24) | class MultilingualTransformerModel(FairseqMultiModel):
    method __init__ (line 40) | def __init__(self, encoders, decoders):
    method add_args (line 44) | def add_args(parser):
    method build_model (line 69) | def build_model(cls, args, task):
    method load_state_dict (line 192) | def load_state_dict(self, state_dict, strict=True):
  function base_multilingual_architecture (line 203) | def base_multilingual_architecture(args):
  function multilingual_transformer_iwslt_de_en (line 214) | def multilingual_transformer_iwslt_de_en(args):

FILE: packages/fairseq-hacked/fairseq/models/nonautoregressive_ensembles.py
  class _EnsembleModelEncoder (line 21) | class _EnsembleModelEncoder(object):
    method __init__ (line 22) | def __init__(self, models):
    method reorder_encoder_out (line 25) | def reorder_encoder_out(self, encoder_outs, new_order):
  class BasicEnsembleModel (line 33) | class BasicEnsembleModel(torch.nn.Module):
    method __init__ (line 36) | def __init__(self, models):
    method has_encoder (line 45) | def has_encoder(self):
    method max_decoder_positions (line 48) | def max_decoder_positions(self):
    method forward_encoder (line 52) | def forward_encoder(self, encoder_input):
    method forward_decoder (line 58) | def forward_decoder(self, *inputs):
    method initialize_output_tokens (line 61) | def initialize_output_tokens(self, *inputs):
  class EnsembleLevT (line 65) | class EnsembleLevT(BasicEnsembleModel):
    method __init__ (line 68) | def __init__(self, models):
    method forward_decoder (line 72) | def forward_decoder(
    method forward_word_del (line 136) | def forward_word_del(
    method forward_mask_ins (line 172) | def forward_mask_ins(
    method forward_word_ins (line 210) | def forward_word_ins(
    method initialize_output_tokens (line 245) | def initialize_output_tokens(self, encoder_outs, src_tokens):

FILE: packages/fairseq-hacked/fairseq/models/nonautoregressive_transformer.py
  function _mean_pooling (line 21) | def _mean_pooling(enc_feats, src_masks):
  function _argmax (line 34) | def _argmax(x, dim):
  function _uniform_assignment (line 38) | def _uniform_assignment(src_lens, trg_lens):
  class NATransformerModel (line 49) | class NATransformerModel(TransformerModel):
    method __init__ (line 50) | def __init__(self, args, encoder, decoder):
    method add_args (line 59) | def add_args(parser):
    method build_decoder (line 90) | def build_decoder(cls, args, tgt_dict, embed_tokens):
    method build_encoder (line 97) | def build_encoder(cls, args, src_dict, embed_tokens):
    method forward (line 103) | def forward(
    method forward_encoder (line 131) | def forward_encoder(self, encoder_inputs):
    method forward_decoder (line 134) | def forward_decoder(self, decoder_out, encoder_out, decoding_format=No...
    method initialize_output_tokens (line 160) | def initialize_output_tokens(self, encoder_out, src_tokens):
  class NATransformerDecoder (line 189) | class NATransformerDecoder(TransformerDecoder):
    method __init__ (line 190) | def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=Fal...
    method forward (line 207) | def forward(
    method extract_features (line 231) | def extract_features(
    method forward_embedding (line 305) | def forward_embedding(self, prev_output_tokens, states=None):
    method forward_copying_source (line 327) | def forward_copying_source(self, src_embeds, src_masks, tgt_masks):
    method forward_length_prediction (line 342) | def forward_length_prediction(self, encoder_out, tgt_tokens=None):
  function base_architecture (line 385) | def base_architecture(args):
  function nonautoregressive_transformer_wmt_en_de (line 433) | def nonautoregressive_transformer_wmt_en_de(args):

FILE: packages/fairseq-hacked/fairseq/models/roberta/alignment_utils.py
  function align_bpe_to_words (line 12) | def align_bpe_to_words(roberta, bpe_tokens: torch.LongTensor, other_toke...
  function align_features_to_words (line 71) | def align_features_to_words(roberta, features, alignment):
  function spacy_nlp (line 100) | def spacy_nlp():
  function spacy_tokenizer (line 111) | def spacy_tokenizer():

FILE: packages/fairseq-hacked/fairseq/models/roberta/hub_interface.py
  class RobertaHubInterface (line 15) | class RobertaHubInterface(nn.Module):
    method __init__ (line 21) | def __init__(self, args, task, model):
    method device (line 33) | def device(self):
    method encode (line 36) | def encode(
    method decode (line 68) | def decode(self, tokens: torch.LongTensor):
    method extract_features (line 83) | def extract_features(
    method register_classification_head (line 106) | def register_classification_head(
    method predict (line 113) | def predict(self, head: str, tokens: torch.LongTensor, return_logits: ...
    method extract_features_aligned_to_words (line 120) | def extract_features_aligned_to_words(
    method fill_mask (line 157) | def fill_mask(self, masked_input: str, topk: int = 5):
    method disambiguate_pronoun (line 218) | def disambiguate_pronoun(self, sentence: str) -> bool:

FILE: packages/fairseq-hacked/fairseq/models/roberta/model.py
  class RobertaModel (line 30) | class RobertaModel(FairseqLanguageModel):
    method hub_models (line 32) | def hub_models(cls):
    method __init__ (line 40) | def __init__(self, args, encoder):
    method add_args (line 50) | def add_args(parser):
    method build_model (line 132) | def build_model(cls, args, task):
    method forward (line 144) | def forward(
    method register_classification_head (line 161) | def register_classification_head(
    method supported_targets (line 184) | def supported_targets(self):
    method from_pretrained (line 188) | def from_pretrained(
    method upgrade_state_dict_named (line 209) | def upgrade_state_dict_named(self, state_dict, name):
  class XLMRModel (line 270) | class XLMRModel(RobertaModel):
    method hub_models (line 272) | def hub_models(cls):
    method from_pretrained (line 279) | def from_pretrained(
  class CamembertModel (line 302) | class CamembertModel(RobertaModel):
    method hub_models (line 304) | def hub_models(cls):
    method from_pretrained (line 310) | def from_pretrained(
  class RobertaLMHead (line 332) | class RobertaLMHead(nn.Module):
    method __init__ (line 335) | def __init__(self, embed_dim, output_dim, activation_fn, weight=None):
    method forward (line 346) | def forward(self, features, masked_tokens=None, **kwargs):
  class RobertaClassificationHead (line 360) | class RobertaClassificationHead(nn.Module):
    method __init__ (line 363) | def __init__(
    method forward (line 372) | def forward(self, features, **kwargs):
  class RobertaEncoder (line 382) | class RobertaEncoder(FairseqDecoder):
    method __init__ (line 389) | def __init__(self, args, dictionary):
    method forward (line 425) | def forward(
    method extract_features (line 455) | def extract_features(self, src_tokens, return_all_hiddens=False, **unu...
    method output_layer (line 462) | def output_layer(self, features, masked_tokens=None, **unused):
    method max_positions (line 465) | def max_positions(self):
  function base_architecture (line 471) | def base_architecture(args):
  function roberta_base_architecture (line 489) | def roberta_base_architecture(args):
  function roberta_large_architecture (line 494) | def roberta_large_architecture(args):
  function xlm_architecture (line 503) | def xlm_architecture(args):

FILE: packages/fairseq-hacked/fairseq/models/transformer.py
  class TransformerModel (line 36) | class TransformerModel(FairseqEncoderDecoderModel):
    method hub_models (line 54) | def hub_models(cls):
    method __init__ (line 86) | def __init__(self, args, encoder, decoder):
    method add_args (line 92) | def add_args(parser):
    method build_model (line 167) | def build_model(cls, args, task):
    method build_encoder (line 226) | def build_encoder(cls, args, src_dict, embed_tokens):
    method build_decoder (line 230) | def build_decoder(cls, args, tgt_dict, embed_tokens):
  class TransformerAlignModel (line 240) | class TransformerAlignModel(TransformerModel):
    method __init__ (line 246) | def __init__(self, encoder, decoder, args):
    method add_args (line 253) | def add_args(parser):
    method build_model (line 265) | def build_model(cls, args, task):
    method forward (line 274) | def forward(self, src_tokens, src_lengths, prev_output_tokens):
    method forward_decoder (line 278) | def forward_decoder(
  class TransformerEncoder (line 319) | class TransformerEncoder(FairseqEncoder):
    method __init__ (line 330) | def __init__(self, args, dictionary, embed_tokens):
    method forward_embedding (line 372) | def forward_embedding(self, src_tokens):
    method forward (line 382) | def forward(
    method reorder_encoder_out (line 447) | def reorder_encoder_out(self, encoder_out, new_order):
    method max_positions (line 479) | def max_positions(self):
    method buffered_future_mask (line 485) | def buffered_future_mask(self, tensor):
    method upgrade_state_dict_named (line 501) | def upgrade_state_dict_named(self, state_dict, name):
  class TransformerDecoder (line 526) | class TransformerDecoder(FairseqIncrementalDecoder):
    method __init__ (line 539) | def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=Fal...
    method forward (line 621) | def forward(
    method extract_features (line 655) | def extract_features(
    method output_layer (line 775) | def output_layer(self, features, **kwargs):
    method max_positions (line 786) | def max_positions(self):
    method buffered_future_mask (line 792) | def buffered_future_mask(self, tensor):
    method upgrade_state_dict_named (line 805) | def upgrade_state_dict_named(self, state_dict, name):
  function Embedding (line 841) | def Embedding(num_embeddings, embedding_dim, padding_idx):
  function Linear (line 848) | def Linear(in_features, out_features, bias=True):
  function base_architecture (line 857) | def base_architecture(args):
  function transformer_iwslt_de_en (line 902) | def transformer_iwslt_de_en(args):
  function transformer_wmt_en_de (line 915) | def transformer_wmt_en_de(args):
  function transformer_vaswani_wmt_en_de_big (line 921) | def transformer_vaswani_wmt_en_de_big(args):
  function transformer_vaswani_wmt_en_fr_big (line 934) | def transformer_vaswani_wmt_en_fr_big(args):
  function transformer_wmt_en_de_big (line 940) | def transformer_wmt_en_de_big(args):
  function transformer_wmt_en_de_big_t2t (line 947) | def transformer_wmt_en_de_big_t2t(args):
  function transformer_align (line 956) | def transformer_align(args):
  function transformer_wmt_en_de_big_align (line 964) | def transformer_wmt_en_de_big_align(args):

FILE: packages/fairseq-hacked/fairseq/models/transformer_from_pretrained_xlm.py
  class TransformerFromPretrainedXLMModel (line 21) | class TransformerFromPretrainedXLMModel(TransformerModel):
    method add_args (line 23) | def add_args(parser):
    method build_model (line 44) | def build_model(self, args, task, cls_dictionary=MaskedLMDictionary):
    method build_encoder (line 65) | def build_encoder(cls, args, src_dict, embed_tokens):
    method build_decoder (line 69) | def build_decoder(cls, args, tgt_dict, embed_tokens):
  function upgrade_state_dict_with_xlm_weights (line 73) | def upgrade_state_dict_with_xlm_weights(
  class TransformerEncoderFromPretrainedXLM (line 112) | class TransformerEncoderFromPretrainedXLM(TransformerEncoder):
    method __init__ (line 113) | def __init__(self, args, dictionary, embed_tokens):
  class TransformerDecoderFromPretrainedXLM (line 130) | class TransformerDecoderFromPretrainedXLM(TransformerDecoder):
    method __init__ (line 131) | def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=Fal...
  function base_architecture (line 151) | def base_architecture(args):

FILE: packages/fairseq-hacked/fairseq/models/transformer_lm.py
  class TransformerLanguageModel (line 25) | class TransformerLanguageModel(FairseqLanguageModel):
    method hub_models (line 27) | def hub_models(cls):
    method __init__ (line 49) | def __init__(self, decoder):
    method add_args (line 53) | def add_args(parser):
    method build_model (line 125) | def build_model(cls, args, task):
  function base_lm_architecture (line 180) | def base_lm_architecture(args):
  function transformer_lm_big (line 234) | def transformer_lm_big(args):
  function transformer_lm_baevski_wiki103 (line 244) | def transformer_lm_baevski_wiki103(args):
  function transformer_lm_baevski_gbw (line 264) | def transformer_lm_baevski_gbw(args):
  function transformer_lm_gpt (line 273) | def transformer_lm_gpt(args):
  function transformer_lm_gpt2_small (line 285) | def transformer_lm_gpt2_small(args):
  function transformer_lm_gpt2_medium (line 297) | def transformer_lm_gpt2_medium(args):
  function transformer_lm_gpt2_big (line 309) | def transformer_lm_gpt2_big(args):

FILE: packages/fairseq-hacked/fairseq/models/wav2vec.py
  class Wav2VecModel (line 18) | class Wav2VecModel(BaseFairseqModel):
    method add_args (line 20) | def add_args(parser):
    method build_model (line 143) | def build_model(cls, args, task):
    method __init__ (line 153) | def __init__(self, args):
    method forward (line 245) | def forward(self, source):
    method upgrade_state_dict_named (line 262) | def upgrade_state_dict_named(self, state_dict, name):
    method max_positions (line 265) | def max_positions(self):
    method get_logits (line 269) | def get_logits(self, net_output):
    method get_targets (line 273) | def get_targets(self, sample, net_output, expand_steps=True):
    method get_target_weights (line 277) | def get_target_weights(self, targets, net_output):
  class TransposeLast (line 284) | class TransposeLast(nn.Module):
    method __init__ (line 285) | def __init__(self, deconstruct_idx=None):
    method forward (line 289) | def forward(self, x):
  class Fp32GroupNorm (line 295) | class Fp32GroupNorm(nn.GroupNorm):
    method __init__ (line 296) | def __init__(self, *args, **kwargs):
    method forward (line 299) | def forward(self, input):
  class Fp32LayerNorm (line 310) | class Fp32LayerNorm(nn.LayerNorm):
    method __init__ (line 311) | def __init__(self, *args, **kwargs):
    method forward (line 314) | def forward(self, input):
  function norm_block (line 325) | def norm_block(is_layer_norm, dim, affine=True):
  class ConvFeatureExtractionModel (line 338) | class ConvFeatureExtractionModel(nn.Module):
    method __init__ (line 339) | def __init__(
    method forward (line 370) | def forward(self, x):
  class ZeroPad1d (line 391) | class ZeroPad1d(nn.Module):
    method __init__ (line 392) | def __init__(self, pad_left, pad_right):
    method forward (line 397) | def forward(self, x):
  class ConvAggegator (line 401) | class ConvAggegator(nn.Module):
    method __init__ (line 402) | def __init__(
    method forward (line 447) | def forward(self, x):
  class Wav2VecPredictionsModel (line 458) | class Wav2VecPredictionsModel(nn.Module):
    method __init__ (line 459) | def __init__(
    method sample_negatives (line 484) | def sample_negatives(self, y):
    method forward (line 532) | def forward(self, x, y):
  function base_wav2vec_architecture (line 576) | def base_wav2vec_architecture(args):

FILE: packages/fairseq-hacked/fairseq/modules/adaptive_input.py
  class AdaptiveInput (line 13) | class AdaptiveInput(nn.Module):
    method __init__ (line 14) | def __init__(
    method weights_for_band (line 58) | def weights_for_band(self, band: int):
    method forward (line 61) | def forward(self, input: torch.Tensor):

FILE: packages/fairseq-hacked/fairseq/modules/adaptive_softmax.py
  class TiedLinear (line 14) | class TiedLinear(nn.Module):
    method __init__ (line 15) | def __init__(self, weight, transpose):
    method forward (line 20) | def forward(self, input):
  class TiedHeadModule (line 24) | class TiedHeadModule(nn.Module):
    method __init__ (line 25) | def __init__(self, weights, input_dim, num_classes):
    method forward (line 41) | def forward(self, input):
  class AdaptiveSoftmax (line 49) | class AdaptiveSoftmax(nn.Module):
    method __init__ (line 56) | def __init__(
    method _make_tail (line 106) | def _make_tail(self, adaptive_inputs=None, tie_proj=False):
    method upgrade_state_dict_named (line 135) | def upgrade_state_dict_named(self, state_dict, name):
    method adapt_target (line 140) | def adapt_target(self, target):
    method forward (line 165) | def forward(self, input, target):
    method get_log_prob (line 188) | def get_log_prob(self, input, target):

FILE: packages/fairseq-hacked/fairseq/modules/beamable_mm.py
  class BeamableMM (line 10) | class BeamableMM(nn.Module):
    method __init__ (line 19) | def __init__(self, beam_size=None):
    method forward (line 23) | def forward(self, input1, input2):
    method set_beam_size (line 48) | def set_beam_size(self, beam_size):

FILE: packages/fairseq-hacked/fairseq/modules/character_token_embedder.py
  class CharacterTokenEmbedder (line 20) | class CharacterTokenEmbedder(torch.nn.Module):
    method __init__ (line 21) | def __init__(
    method prepare_for_onnx_export_ (line 62) | def prepare_for_onnx_export_(self):
    method set_vocab (line 65) | def set_vocab(self, vocab, max_char_len):
    method padding_idx (line 92) | def padding_idx(self):
    method reset_parameters (line 95) | def reset_parameters(self):
    method forward (line 105) | def forward(
    method _convolve (line 152) | def _convolve(

FILE: packages/fairseq-hacked/fairseq/modules/conv_tbc.py
  class ConvTBC (line 10) | class ConvTBC(torch.nn.Module):
    method __init__ (line 17) | def __init__(self, in_channels, out_channels, kernel_size, padding=0):
    method forward (line 29) | def forward(self, input):
    method __repr__ (line 34) | def __repr__(self):

FILE: packages/fairseq-hacked/fairseq/modules/downsampled_multihead_attention.py
  class SingleHeadAttention (line 15) | class SingleHeadAttention(nn.Module):
    method __init__ (line 20) | def __init__(
    method forward (line 71) | def forward(
  class DownsampledMultiHeadAttention (line 166) | class DownsampledMultiHeadAttention(nn.ModuleList):
    method __init__ (line 171) | def __init__(
    method forward (line 227) | def forward(
  class Downsample (line 284) | class Downsample(nn.Module):
    method __init__ (line 289) | def __init__(self, index):
    method forward (line 293) | def forward(self, x):
  function Linear (line 297) | def Linear(in_features, out_features, dropout=0.0, bias=True):
  function GatedLinear (line 305) | def GatedLinear(in_features, out_features, dropout=0.0, bias=True):

FILE: packages/fairseq-hacked/fairseq/modules/dynamic_convolution.py
  function DynamicConv (line 14) | def DynamicConv(
  function Linear (line 53) | def Linear(in_features, out_features, bias=True):
  class DynamicConv1dTBC (line 61) | class DynamicConv1dTBC(nn.Module):
    method __init__ (line 86) | def __init__(
    method in_proj (line 125) | def in_proj(self):
    method reset_parameters (line 131) | def reset_parameters(self):
    method forward (line 136) | def forward(self, x, incremental_state=None, query=None, unfold=None):
    method _forward_unfolded (line 161) | def _forward_unfolded(self, x, incremental_state, query):
    method _forward_expanded (line 219) | def _forward_expanded(self, x, incremental_stat, query):
    method reorder_incremental_state (line 278) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 284) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 287) | def _set_input_buffer(self, incremental_state, new_buffer):
    method extra_repr (line 292) | def extra_repr(self):

FILE: packages/fairseq-hacked/fairseq/modules/dynamicconv_layer/cuda_function_gen.py
  function gen_forward (line 7) | def gen_forward():
  function gen_backward (line 96) | def gen_backward():

FILE: packages/fairseq-hacked/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cpp
  function dynamicconv_forward (line 27) | std::vector<at::Tensor> dynamicconv_forward(
  function dynamicconv_backward (line 39) | std::vector<at::Tensor> dynamicconv_backward(
  function PYBIND11_MODULE (line 53) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: packages/fairseq-hacked/fairseq/modules/dynamicconv_layer/dynamicconv_layer.py
  class dynamicconvFunction (line 16) | class dynamicconvFunction(Function):
    method forward (line 18) | def forward(ctx, x, weights, padding_l):
    method backward (line 26) | def backward(ctx, grad_output):
  class DynamicconvLayer (line 34) | class DynamicconvLayer(nn.Module):
    method __init__ (line 35) | def __init__(
    method reset_parameters (line 67) | def reset_parameters(self):
    method forward (line 73) | def forward(self, x, incremental_state=None, query=None, unfold=None):
    method reorder_incremental_state (line 117) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 123) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 126) | def _set_input_buffer(self, incremental_state, new_buffer):
    method _forward_unfolded (line 131) | def _forward_unfolded(self, x, incremental_state, query):
    method _forward_expanded (line 182) | def _forward_expanded(self, x, incremental_stat, query):

FILE: packages/fairseq-hacked/fairseq/modules/dynamicconv_layer/dynamiconv_cpu.cpp
  function dynamicconv_forward (line 15) | std::vector<float*> dynamicconv_forward(
  function dynamicconv_backward (line 23) | std::vector<float*> dynamicconv_backward(
  function PYBIND11_MODULE (line 32) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: packages/fairseq-hacked/fairseq/modules/gelu.py
  function gelu_accurate (line 15) | def gelu_accurate(x):
  function gelu (line 23) | def gelu(x: torch.Tensor) -> torch.Tensor:

FILE: packages/fairseq-hacked/fairseq/modules/grad_multiply.py
  class GradMultiply (line 9) | class GradMultiply(torch.autograd.Function):
    method forward (line 11) | def forward(ctx, x, scale):
    method backward (line 17) | def backward(ctx, grad):

FILE: packages/fairseq-hacked/fairseq/modules/highway.py
  class Highway (line 11) | class Highway(torch.nn.Module):
    method __init__ (line 17) | def __init__(self, input_dim: int, num_layers: int = 1):
    method reset_parameters (line 27) | def reset_parameters(self):
    method forward (line 39) | def forward(self, x: torch.Tensor):

FILE: packages/fairseq-hacked/fairseq/modules/layer_norm.py
  function LayerNorm (line 9) | def LayerNorm(normalized_shape, eps=1e-5, elementwise_affine=True, expor...

FILE: packages/fairseq-hacked/fairseq/modules/learned_positional_embedding.py
  class LearnedPositionalEmbedding (line 11) | class LearnedPositionalEmbedding(nn.Embedding):
    method __init__ (line 19) | def __init__(
    method forward (line 25) | def forward(self, input, incremental_state=None, positions=None):
    method max_positions (line 44) | def max_positions(self):

FILE: packages/fairseq-hacked/fairseq/modules/lightconv_layer/cuda_function_gen.py
  function gen_forward (line 7) | def gen_forward():
  function gen_backward (line 116) | def gen_backward():

FILE: packages/fairseq-hacked/fairseq/modules/lightconv_layer/lightconv_cuda.cpp
  function lightconv_forward (line 27) | std::vector<at::Tensor> lightconv_forward(
  function lightconv_backward (line 38) | std::vector<at::Tensor> lightconv_backward(
  function PYBIND11_MODULE (line 51) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: packages/fairseq-hacked/fairseq/modules/lightconv_layer/lightconv_layer.py
  class lightconvFunction (line 15) | class lightconvFunction(Function):
    method forward (line 17) | def forward(ctx, x, weights, padding_l):
    method backward (line 25) | def backward(ctx, grad_output):
  class LightconvLayer (line 33) | class LightconvLayer(nn.Module):
    method __init__ (line 34) | def __init__(
    method reset_parameters (line 59) | def reset_parameters(self):
    method forward (line 64) | def forward(self, x, incremental_state=None):
    method reorder_incremental_state (line 111) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 117) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 120) | def _set_input_buffer(self, incremental_state, new_buffer):
    method half (line 125) | def half(self):

FILE: packages/fairseq-hacked/fairseq/modules/lightweight_convolution.py
  function LightweightConv (line 14) | def LightweightConv(
  class LightweightConv1d (line 49) | class LightweightConv1d(nn.Module):
    method __init__ (line 72) | def __init__(
    method reset_parameters (line 97) | def reset_parameters(self):
    method forward (line 102) | def forward(self, input):
  class LightweightConv1dTBC (line 128) | class LightweightConv1dTBC(nn.Module):
    method __init__ (line 149) | def __init__(
    method reset_parameters (line 177) | def reset_parameters(self):
    method forward (line 182) | def forward(self, x, incremental_state=None, unfold=False):
    method prepare_for_onnx_export_ (line 200) | def prepare_for_onnx_export_(self):
    method _forward_unfolded (line 203) | def _forward_unfolded(self, x, incremental_state):
    method _forward_expanded (line 245) | def _forward_expanded(self, x, incremental_state):
    method reorder_incremental_state (line 282) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 288) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 291) | def _set_input_buffer(self, incremental_state, new_buffer):
    method extra_repr (line 296) | def extra_repr(self):

FILE: packages/fairseq-hacked/fairseq/modules/linearized_convolution.py
  class LinearizedConvolution (line 14) | class LinearizedConvolution(ConvTBC):
    method __init__ (line 23) | def __init__(self, in_channels, out_channels, kernel_size, **kwargs):
    method forward (line 28) | def forward(self, input, incremental_state=None):
    method reorder_incremental_state (line 66) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 72) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 75) | def _set_input_buffer(self, incremental_state, new_buffer):
    method _get_linearized_weight (line 80) | def _get_linearized_weight(self):
    method _clear_linearized_weight (line 90) | def _clear_linearized_weight(self, *args):

FILE: packages/fairseq-hacked/fairseq/modules/logsumexp_moe.py
  class LogSumExpMoE (line 9) | class LogSumExpMoE(torch.autograd.Function):
    method forward (line 17) | def forward(ctx, logp, posterior, dim=-1):
    method backward (line 23) | def backward(ctx, grad_output):

FILE: packages/fairseq-hacked/fairseq/modules/mean_pool_gating_network.py
  class MeanPoolGatingNetwork (line 10) | class MeanPoolGatingNetwork(torch.nn.Module):
    method __init__ (line 18) | def __init__(self, embed_dim, num_experts, dropout=None):
    method forward (line 27) | def forward(self, encoder_out):

FILE: packages/fairseq-hacked/fairseq/modules/multihead_attention.py
  class MultiheadAttention (line 15) | class MultiheadAttention(nn.Module):
    method __init__ (line 21) | def __init__(
    method prepare_for_onnx_export_ (line 79) | def prepare_for_onnx_export_(self):
    method reset_parameters (line 82) | def reset_parameters(self):
    method forward (line 101) | def forward(
    method _append_prev_key_padding_mask (line 351) | def _append_prev_key_padding_mask(
    method reorder_incremental_state (line 378) | def reorder_incremental_state(self, incremental_state, new_order):
    method _get_input_buffer (line 387) | def _get_input_buffer(self, incremental_state):
    method _set_input_buffer (line 390) | def _set_input_buffer(self, incremental_state, buffer):
    method apply_sparse_mask (line 395) | def apply_sparse_mask(self, attn_weights, tgt_len, src_len, bsz):
    method upgrade_state_dict_named (line 398) | def upgrade_state_dict_named(self, state_dict, name):

FILE: packages/fairseq-hacked/fairseq/modules/positional_embedding.py
  function PositionalEmbedding (line 12) | def PositionalEmbedding(

FILE: packages/fairseq-hacked/fairseq/modules/scalar_bias.py
  class ScalarBias (line 10) | class ScalarBias(torch.autograd.Function):
    method forward (line 17) | def forward(ctx, input, dim, bias_init):
    method backward (line 26) | def backward(ctx, grad):
  function scalar_bias (line 30) | def scalar_bias(input, dim, bias_init=0):

FILE: packages/fairseq-hacked/fairseq/modules/sinusoidal_positional_embedding.py
  class SinusoidalPositionalEmbedding (line 15) | class SinusoidalPositionalEmbedding(nn.Module):
    method __init__ (line 21) | def __init__(self, embedding_dim, padding_idx, init_size=1024):
    method prepare_for_onnx_export_ (line 31) | def prepare_for_onnx_export_(self):
    method get_embedding (line 35) | def get_embedding(num_embeddings, embedding_dim, padding_idx=None):
    method forward (line 57) | def forward(self, input, incremental_state=None, timestep=None, **kwar...
    method max_positions (line 97) | def max_positions(self):

FILE: packages/fairseq-hacked/fairseq/modules/sparse_multihead_attention.py
  class SparseMultiheadAttention (line 11) | class SparseMultiheadAttention(MultiheadAttention):
    method __init__ (line 22) | def __init__(
    method compute_checkpoint (line 58) | def compute_checkpoint(self, word_index):
    method compute_subset_summaries (line 70) | def compute_subset_summaries(self, absolute_max):
    method compute_fixed_attention_subset (line 85) | def compute_fixed_attention_subset(self, word_index, tgt_len):
    method buffered_sparse_mask (line 117) | def buffered_sparse_mask(self, tensor, tgt_len, src_len):
    method apply_sparse_mask (line 133) | def apply_sparse_mask(self, attn_weights, tgt_len, src_len, bsz):

FILE: packages/fairseq-hacked/fairseq/modules/sparse_transformer_sentence_encoder.py
  class SparseTransformerSentenceEncoder (line 13) | class SparseTransformerSentenceEncoder(TransformerSentenceEncoder):
    method __init__ (line 19) | def __init__(

FILE: packages/fairseq-hacked/fairseq/modules/sparse_transformer_sentence_encoder_layer.py
  class SparseTransformerSentenceEncoderLayer (line 10) | class SparseTransformerSentenceEncoderLayer(TransformerSentenceEncoderLa...
    method __init__ (line 15) | def __init__(

FILE: packages/fairseq-hacked/fairseq/modules/transformer_layer.py
  class TransformerEncoderLayer (line 13) | class TransformerEncoderLayer(nn.Module):
    method __init__ (line 28) | def __init__(self, args):
    method upgrade_state_dict_named (line 51) | def upgrade_state_dict_named(self, state_dict, name):
    method forward (line 65) | def forward(self, x, encoder_padding_mask, attn_mask=None):
    method maybe_layer_norm (line 109) | def maybe_layer_norm(self, layer_norm, x, before=False, after=False):
  class TransformerDecoderLayer (line 117) | class TransformerDecoderLayer(nn.Module):
    method __init__ (line 134) | def __init__(
    method prepare_for_onnx_export_ (line 186) | def prepare_for_onnx_export_(self):
    method forward (line 189) | def forward(
    method maybe_layer_norm (line 310) | def maybe_layer_norm(self, layer_norm, x, before=False, after=False):
    method make_generation_fast_ (line 317) | def make_generation_fast_(self, need_attn=False, **kwargs):
  function Linear (line 321) | def Linear(in_features, out_features, bias=True):

FILE: packages/fairseq-hacked/fairseq/modules/transformer_sentence_encoder.py
  function init_bert_params (line 20) | def init_bert_params(module):
  class TransformerSentenceEncoder (line 48) | class TransformerSentenceEncoder(nn.Module):
    method __init__ (line 72) | def __init__(
    method forward (line 177) | def forward(

FILE: packages/fairseq-hacked/fairseq/modules/transformer_sentence_encoder_layer.py
  class TransformerSentenceEncoderLayer (line 17) | class TransformerSentenceEncoderLayer(nn.Module):
    method __init__ (line 23) | def __init__(
    method forward (line 62) | def forward(

FILE: packages/fairseq-hacked/fairseq/modules/unfold.py
  function unfold1d (line 9) | def unfold1d(x, kernel_size, padding_l, pad_value=0):

FILE: packages/fairseq-hacked/fairseq/modules/vggblock.py
  function _pair (line 15) | def _pair(v):
  function infer_conv_output_dim (line 22) | def infer_conv_output_dim(conv_op, input_dim, sample_inchannel):
  class VGGBlock (line 38) | class VGGBlock(torch.nn.Module):
    method __init__ (line 60) | def __init__(
    method forward (line 113) | def forward(self, x):

FILE: packages/fairseq-hacked/fairseq/optim/adadelta.py
  class Adadelta (line 12) | class Adadelta(FairseqOptimizer):
    method __init__ (line 13) | def __init__(self, args, params):
    method add_args (line 18) | def add_args(parser):
    method optimizer_config (line 31) | def optimizer_config(self):

FILE: packages/fairseq-hacked/fairseq/optim/adafactor.py
  class FairseqAdafactor (line 14) | class FairseqAdafactor(FairseqOptimizer):
    method __init__ (line 15) | def __init__(self, args, params):
    method add_args (line 20) | def add_args(parser):
    method optimizer_config (line 43) | def optimizer_config(self):
  class Adafactor (line 65) | class Adafactor(torch.optim.Optimizer):
    method __init__ (line 93) | def __init__(
    method supports_memory_efficient_fp16 (line 120) | def supports_memory_efficient_fp16(self):
    method _get_lr (line 123) | def _get_lr(self, param_group, param_state):
    method _get_options (line 135) | def _get_options(self, param_group, param_shape):
    method _rms (line 140) | def _rms(self, tensor):
    method _approx_sq_grad (line 143) | def _approx_sq_grad(self, exp_avg_sq_row, exp_avg_sq_col, output):
    method step (line 152) | def step(self, closure=None):

FILE: packages/fairseq-hacked/fairseq/optim/adagrad.py
  class Adagrad (line 12) | class Adagrad(FairseqOptimizer):
    method __init__ (line 13) | def __init__(self, args, params):
    method add_args (line 18) | def add_args(parser):
    method optimizer_config (line 26) | def optimizer_config(self):

FILE: packages/fairseq-hacked/fairseq/optim/adam.py
  class FairseqAdam (line 17) | class FairseqAdam(FairseqOptimizer):
    method __init__ (line 25) | def __init__(self, args, params):
    method add_args (line 38) | def add_args(parser):
    method optimizer_config (line 50) | def optimizer_config(self):
    method average_params (line 64) | def average_params(self):
  class Adam (line 76) | class Adam(torch.optim.Optimizer):
    method __init__ (line 103) | def __init__(
    method supports_memory_efficient_fp16 (line 118) | def supports_memory_efficient_fp16(self):
    method step (line 121) | def step(self, closure=None):
  class FusedAdam (line 197) | class FusedAdam(torch.optim.Optimizer):
    method __init__ (line 229) | def __init__(
    method supports_memory_efficient_fp16 (line 260) | def supports_memory_efficient_fp16(self):
    method step (line 263) | def step(self, closure=None, grads=None, scale=1.0, grad_norms=None):

FILE: packages/fairseq-hacked/fairseq/optim/adamax.py
  class FairseqAdamax (line 13) | class FairseqAdamax(FairseqOptimizer):
    method __init__ (line 14) | def __init__(self, args, params):
    method add_args (line 19) | def add_args(parser):
    method optimizer_config (line 33) | def optimizer_config(self):
  class Adamax (line 49) | class Adamax(torch.optim.Optimizer):
    method __init__ (line 70) | def __init__(
    method supports_memory_efficient_fp16 (line 100) | def supports_memory_efficient_fp16(self):
    method step (line 103) | def step(self, closure=None):

FILE: packages/fairseq-hacked/fairseq/optim/bmuf.py
  class FairseqBMUF (line 12) | class FairseqBMUF(FairseqOptimizer):
    method __init__ (line 22) | def __init__(self, args, optimizer):
    method add_args (line 37) | def add_args(parser):
    method optimizer (line 74) | def optimizer(self):
    method optimizer_config (line 78) | def optimizer_config(self):
    method get_lr (line 81) | def get_lr(self):
    method set_lr (line 84) | def set_lr(self, lr):
    method state_dict (line 87) | def state_dict(self):
    method load_state_dict (line 90) | def load_state_dict(self, state_dict, optimizer_overrides=None):
    method multiply_grads (line 93) | def multiply_grads(self, c):
    method clip_grad_norm (line 97) | def clip_grad_norm(self, max_norm):
    method average_params (line 101) | def average_params(self):
    method _block_sync (line 104) | def _block_sync(self):
    method _is_warmup_end (line 122) | def _is_warmup_end(self):
    method _is_bmuf_iter (line 128) | def _is_bmuf_iter(self):
    method _warmup_sync (line 136) | def _warmup_sync(self, root_rank=0):
    method step (line 149) | def step(self, closure=None):
    method zero_grad (line 158) | def zero_grad(self):
    method get_num_updates (line 162) | def get_num_updates(self):
    method set_num_updates (line 166) | def set_num_updates(self, num_updates):
    method _reset_local_data (line 171) | def _reset_local_data(self):
    method _calc_grad (line 182) | def _calc_grad(self):
    method _avg_grad_from_all_gpus (line 192) | def _avg_grad_from_all_gpus(self):
    method _update_global_model (line 199) | def _update_global_model(self):

FILE: packages/fairseq-hacked/fairseq/optim/fairseq_optimizer.py
  class FairseqOptimizer (line 11) | class FairseqOptimizer(object):
    method __init__ (line 12) | def __init__(self, args):
    method add_args (line 17) | def add_args(parser):
    method optimizer (line 22) | def optimizer(self):
    method optimizer_config (line 31) | def optimizer_config(self):
    method params (line 41) | def params(self):
    method __getstate__ (line 47) | def __getstate__(self):
    method get_lr (line 50) | def get_lr(self):
    method set_lr (line 54) | def set_lr(self, lr):
    method state_dict (line 59) | def state_dict(self):
    method load_state_dict (line 63) | def load_state_dict(self, state_dict, optimizer_overrides=None):
    method backward (line 78) | def backward(self, loss):
    method multiply_grads (line 82) | def multiply_grads(self, c):
    method clip_grad_norm (line 88) | def clip_grad_norm(self, max_norm):
    method step (line 97) | def step(self, closure=None):
    method zero_grad (line 101) | def zero_grad(self):
    method supports_memory_efficient_fp16 (line 108) | def supports_memory_efficient_fp16(self):
    method average_params (line 113) | def average_params(self):

FILE: packages/fairseq-hacked/fairseq/optim/fp16_optimizer.py
  class DynamicLossScaler (line 13) | class DynamicLossScaler(object):
    method __init__ (line 14) | def __init__(
    method update_scale (line 32) | def update_scale(self, overflow):
    method _decrease_loss_scale (line 47) | def _decrease_loss_scale(self):
    method has_overflow (line 53) | def has_overflow(grad_norm):
  class _FP16OptimizerMixin (line 60) | class _FP16OptimizerMixin(object):
    method __init__ (line 61) | def __init__(self, *args, **kwargs):
    method build_fp32_params (line 66) | def build_fp32_params(cls, params):
    method state_dict (line 79) | def state_dict(self):
    method load_state_dict (line 85) | def load_state_dict(self, state_dict, optimizer_overrides=None):
    method backward (line 97) | def backward(self, loss):
    method _sync_fp16_grads_to_fp32 (line 108) | def _sync_fp16_grads_to_fp32(self, multiply_grads=1.0):
    method multiply_grads (line 131) | def multiply_grads(self, c):
    method clip_grad_norm (line 138) | def clip_grad_norm(self, max_norm):
    method step (line 160) | def step(self, closure=None):
    method zero_grad (line 174) | def zero_grad(self):
  class FP16Optimizer (line 181) | class FP16Optimizer(_FP16OptimizerMixin, optim.FairseqOptimizer):
    method __init__ (line 186) | def __init__(self, args, params, fp32_optimizer, fp32_params):
    method build_optimizer (line 211) | def build_optimizer(cls, args, params):
    method optimizer (line 222) | def optimizer(self):
    method optimizer_config (line 226) | def optimizer_config(self):
    method get_lr (line 229) | def get_lr(self):
    method set_lr (line 232) | def set_lr(self, lr):
  class _MemoryEfficientFP16OptimizerMixin (line 236) | class _MemoryEfficientFP16OptimizerMixin(object):
    method __init__ (line 237) | def __init__(self, *args, **kwargs):
    method state_dict (line 241) | def state_dict(self):
    method load_state_dict (line 247) | def load_state_dict(self, state_dict, optimizer_overrides=None):
    method backward (line 279) | def backward(self, loss):
    method _unscale_grads (line 290) | def _unscale_grads(self, multiply_grads=1.0):
    method multiply_grads (line 301) | def multiply_grads(self, c):
    method clip_grad_norm (line 308) | def clip_grad_norm(self, max_norm):
    method step (line 331) | def step(self, closure=None):
    method zero_grad (line 336) | def zero_grad(self):
  class MemoryEfficientFP16Optimizer (line 342) | class MemoryEfficientFP16Optimizer(
    method __init__ (line 360) | def __init__(self, args, params, optimizer):
    method build_optimizer (line 388) | def build_optimizer(cls, args, params):
    method optimizer (line 398) | def optimizer(self):
    method optimizer_config (line 402) | def optimizer_config(self):
    method get_lr (line 405) | def get_lr(self):
    method set_lr (line 408) | def set_lr(self, lr):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/cosine_lr_scheduler.py
  class CosineSchedule (line 12) | class CosineSchedule(FairseqLRScheduler):
    method __init__ (line 35) | def __init__(self, args, optimizer):
    method add_args (line 75) | def add_args(parser):
    method step (line 92) | def step(self, epoch, val_loss=None):
    method step_update (line 98) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/fairseq_lr_scheduler.py
  class FairseqLRScheduler (line 9) | class FairseqLRScheduler(object):
    method __init__ (line 10) | def __init__(self, args, optimizer):
    method add_args (line 19) | def add_args(parser):
    method state_dict (line 23) | def state_dict(self):
    method load_state_dict (line 27) | def load_state_dict(self, state_dict):
    method step (line 31) | def step(self, epoch, val_loss=None):
    method step_update (line 39) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/fixed_schedule.py
  class FixedSchedule (line 10) | class FixedSchedule(FairseqLRScheduler):
    method __init__ (line 13) | def __init__(self, args, optimizer):
    method add_args (line 26) | def add_args(parser):
    method get_next_lr (line 37) | def get_next_lr(self, epoch):
    method step (line 49) | def step(self, epoch, val_loss=None):
    method step_update (line 56) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/inverse_square_root_schedule.py
  class InverseSquareRootSchedule (line 10) | class InverseSquareRootSchedule(FairseqLRScheduler):
    method __init__ (line 29) | def __init__(self, args, optimizer):
    method add_args (line 51) | def add_args(parser):
    method step (line 60) | def step(self, epoch, val_loss=None):
    method step_update (line 66) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/polynomial_decay_schedule.py
  class PolynomialDecaySchedule (line 10) | class PolynomialDecaySchedule(FairseqLRScheduler):
    method __init__ (line 13) | def __init__(self, args, optimizer):
    method add_args (line 30) | def add_args(parser):
    method get_next_lr (line 50) | def get_next_lr(self, epoch):
    method step (line 60) | def step(self, epoch, val_loss=None):
    method step_update (line 67) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/reduce_lr_on_plateau.py
  class ReduceLROnPlateau (line 12) | class ReduceLROnPlateau(FairseqLRScheduler):
    method __init__ (line 25) | def __init__(self, args, optimizer):
    method add_args (line 54) | def add_args(parser):
    method state_dict (line 68) | def state_dict(self):
    method load_state_dict (line 75) | def load_state_dict(self, state_dict):
    method step (line 81) | def step(self, epoch, val_loss=None):
    method step_update (line 90) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/tri_stage_lr_scheduler.py
  class TriStageLRSchedule (line 11) | class TriStageLRSchedule(FairseqLRScheduler):
    method __init__ (line 49) | def __init__(self, args, optimizer):
    method add_args (line 75) | def add_args(parser):
    method _decide_stage (line 113) | def _decide_stage(self, update_step):
    method step (line 138) | def step(self, epoch, val_loss=None):
    method step_update (line 144) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/lr_scheduler/triangular_lr_scheduler.py
  class TriangularSchedule (line 12) | class TriangularSchedule(FairseqLRScheduler):
    method __init__ (line 18) | def __init__(self, args, optimizer):
    method add_args (line 40) | def add_args(parser):
    method step (line 53) | def step(self, epoch, val_loss=None):
    method step_update (line 59) | def step_update(self, num_updates):

FILE: packages/fairseq-hacked/fairseq/optim/nag.py
  class FairseqNAG (line 13) | class FairseqNAG(FairseqOptimizer):
    method __init__ (line 14) | def __init__(self, args, params):
    method add_args (line 19) | def add_args(parser):
    method optimizer_config (line 29) | def optimizer_config(self):
  class NAG (line 43) | class NAG(Optimizer):
    method __init__ (line 44) | def __init__(self, params, lr=required, momentum=0, weight_decay=0):
    method supports_memory_efficient_fp16 (line 49) | def supports_memory_efficient_fp16(self):
    method step (line 52) | def step(self, closure=None):

FILE: packages/fairseq-hacked/fairseq/optim/sgd.py
  class SGD (line 12) | class SGD(FairseqOptimizer):
    method __init__ (line 13) | def __init__(self, args, params):
    method add_args (line 18) | def add_args(parser):
    method optimizer_config (line 28) | def optimizer_config(self):

FILE: packages/fairseq-hacked/fairseq/options.py
  function get_preprocessing_parser (line 15) | def get_preprocessing_parser(default_task="translation"):
  function get_training_parser (line 21) | def get_training_parser(default_task="translation"):
  function get_generation_parser (line 31) | def get_generation_parser(interactive=False, default_task="translation"):
  function get_interactive_generation_parser (line 40) | def get_interactive_generation_parser(default_task="translation"):
  function get_eval_lm_parser (line 44) | def get_eval_lm_parser(default_task="language_modeling"):
  function get_validation_parser (line 51) | def get_validation_parser(default_task=None):
  function eval_str_list (line 59) | def eval_str_list(x, type=float):
  function eval_bool (line 70) | def eval_bool(x, default=False):
  function parse_args_and_arch (line 79) | def parse_args_and_arch(
  function get_parser (line 161) | def get_parser(desc, default_task="translation"):
  function add_preprocess_args (line 217) | def add_preprocess_args(parser):
  function add_dataset_args (line 263) | def add_dataset_args(parser, train=False, gen=False):
  function add_distributed_training_args (line 311) | def add_distributed_training_args(parser):
  function add_optimization_args (line 349) | def add_optimization_args(parser):
  function add_checkpoint_args (line 376) | def add_checkpoint_args(parser):
  function add_common_eval_args (line 418) | def add_common_eval_args(group):
  function add_eval_lm_args (line 434) | def add_eval_lm_args(parser):
  function add_generation_args (line 451) | def add_generation_args(parser):
  function add_interactive_args (line 521) | def add_interactive_args(parser):
  function add_model_args (line 531) | def add_model_args(parser):

FILE: packages/fairseq-hacked/fairseq/pdb.py
  class MultiprocessingPdb (line 23) | class MultiprocessingPdb(pdb.Pdb):
    method __init__ (line 29) | def __init__(self):
    method _cmdloop (line 32) | def _cmdloop(self):
  function set_trace (line 45) | def set_trace():

FILE: packages/fairseq-hacked/fairseq/progress_bar.py
  function build_progress_bar (line 20) | def build_progress_bar(
  function format_stat (line 53) | def format_stat(stat):
  class progress_bar (line 65) | class progress_bar(object):
    method __init__ (line 68) | def __init__(self, iterable, epoch=None, prefix=None):
    method __len__ (line 78) | def __len__(self):
    method __enter__ (line 81) | def __enter__(self):
    method __exit__ (line 84) | def __exit__(self, *exc):
    method __iter__ (line 87) | def __iter__(self):
    method log (line 90) | def log(self, stats, tag="", step=None):
    method print (line 94) | def print(self, stats, tag="", step=None):
    method _str_commas (line 98) | def _str_commas(self, stats):
    method _str_pipes (line 101) | def _str_pipes(self, stats):
    method _format_stats (line 104) | def _format_stats(self, stats):
  class json_progress_bar (line 112) | class json_progress_bar(progress_bar):
    method __init__ (line 115) | def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000):
    method __iter__ (line 120) | def __iter__(self):
    method log (line 136) | def log(self, stats, tag="", step=None):
    method print (line 140) | def print(self, stats, tag="", step=None):
    method _format_stats (line 150) | def _format_stats(self, stats, epoch=None, update=None):
  class noop_progress_bar (line 162) | class noop_progress_bar(progress_bar):
    method __init__ (line 165) | def __init__(self, iterable, epoch=None, prefix=None):
    method __iter__ (line 168) | def __iter__(self):
    method log (line 172) | def log(self, stats, tag="", step=None):
    method print (line 176) | def print(self, stats, tag="", step=None):
  class simple_progress_bar (line 181) | class simple_progress_bar(progress_bar):
    method __init__ (line 184) | def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000):
    method __iter__ (line 189) | def __iter__(self):
    method log (line 205) | def log(self, stats, tag="", step=None):
    method print (line 209) | def print(self, stats, tag="", step=None):
  class tqdm_progress_bar (line 215) | class tqdm_progress_bar(progress_bar):
    method __init__ (line 218) | def __init__(self, iterable, epoch=None, prefix=None):
    method __iter__ (line 224) | def __iter__(self):
    method log (line 227) | def log(self, stats, tag="", step=None):
    method print (line 231) | def print(self, stats, tag="", step=None):
  class tensorboard_log_wrapper (line 237) | class tensorboard_log_wrapper(progress_bar):
    method __init__ (line 240) | def __init__(self, wrapped_bar, tensorboard_logdir, args):
    method _writer (line 257) | def _writer(self, key):
    method __iter__ (line 268) | def __iter__(self):
    method log (line 271) | def log(self, stats, tag="", step=None):
    method print (line 276) | def print(self, stats, tag="", step=None):
    method __exit__ (line 281) | def __exit__(self, *exc):
    method _log_to_tensorboard (line 286) | def _log_to_tensorboard(self, stats, tag="", step=None):

FILE: packages/fairseq-hacked/fairseq/registry.py
  function setup_registry (line 12) | def setup_registry(
  function set_defaults (line 66) | def set_defaults(args, cls):

FILE: packages/fairseq-hacked/fairseq/search.py
  class Search (line 11) | class Search(object):
    method __init__ (line 12) | def __init__(self, tgt_dict):
    method _init_buffers (line 21) | def _init_buffers(self, t):
    method step (line 27) | def step(self, step, lprobs, scores):
    method set_src_lengths (line 49) | def set_src_lengths(self, src_lengths):
  class BeamSearch (line 53) | class BeamSearch(Search):
    method __init__ (line 54) | def __init__(self, tgt_dict):
    method step (line 57) | def step(self, step, lprobs, scores):
  class LengthConstrainedBeamSearch (line 84) | class LengthConstrainedBeamSearch(Search):
    method __init__ (line 85) | def __init__(self, tgt_dict, min_len_a, min_len_b, max_len_a, max_len_b):
    method step (line 93) | def step(self, step, lprobs, scores):
  class DiverseBeamSearch (line 102) | class DiverseBeamSearch(Search):
    method __init__ (line 112) | def __init__(self, tgt_dict, num_groups, diversity_strength):
    method step (line 119) | def step(self, step, lprobs, scores):
  class Sampling (line 170) | class Sampling(Search):
    method __init__ (line 171) | def __init__(self, tgt_dict, sampling_topk=-1, sampling_topp=-1.0):
    method _sample_topp (line 176) | def _sample_topp(self, lprobs):
    method step (line 221) | def step(self, step, lprobs, scores):

FILE: packages/fairseq-hacked/fairseq/sequence_generator.py
  class SequenceGenerator (line 15) | class SequenceGenerator(object):
    method __init__ (line 16) | def __init__(
    method generate (line 103) | def generate(self, models, sample, **kwargs):
    method _generate (line 118) | def _generate(self, model, sample, prefix_tokens=None, bos_token=None,...
  class EnsembleModel (line 574) | class EnsembleModel(torch.nn.Module):
    method __init__ (line 577) | def __init__(self, models):
    method has_encoder (line 584) | def has_encoder(self):
    method max_decoder_positions (line 587) | def max_decoder_positions(self):
    method forward_encoder (line 591) | def forward_encoder(self, encoder_input):
    method forward_decoder (line 597) | def forward_decoder(self, tokens, encoder_outs, temperature=1.0):
    method _decode_one (line 632) | def _decode_one(
    method reorder_encoder_out (line 663) | def reorder_encoder_out(self, encoder_outs, new_order):
    method reorder_incremental_state (line 671) | def reorder_incremental_state(self, new_order):
  class SequenceGeneratorWithAlignment (line 680) | class SequenceGeneratorWithAlignment(SequenceGenerator):
    method __init__ (line 681) | def __init__(self, tgt_dict, left_pad_target=False, **kwargs):
    method generate (line 696) | def generate(self, models, sample, **kwargs):
    method _prepare_batch_for_alignment (line 725) | def _prepare_batch_for_alignment(self, sample, hypothesis):
  class EnsembleModelWithAlignment (line 758) | class EnsembleModelWithAlignment(EnsembleModel):
    method __init__ (line 761) | def __init__(self, models):
    method forward_align (line 764) | def forward_align(self, src_tokens, src_lengths, prev_output_tokens):
    method _decode_one (line 777) | def _decode_one(

FILE: packages/fairseq-hacked/fairseq/sequence_scorer.py
  class SequenceScorer (line 12) | class SequenceScorer(object):
    method __init__ (line 15) | def __init__(self, tgt_dict, softmax_batch=None):
    method generate (line 22) | def generate(self, models, sample, **kwargs):

FILE: packages/fairseq-hacked/fairseq/tasks/__init__.py
  function setup_task (line 16) | def setup_task(args, **kwargs):
  function register_task (line 20) | def register_task(name):
  function get_task (line 81) | def get_task(name):

FILE: packages/fairseq-hacked/fairseq/tasks/audio_pretraining.py
  class AudioPretrainingTask (line 13) | class AudioPretrainingTask(FairseqTask):
    method add_args (line 19) | def add_args(parser):
    method __init__ (line 41) | def __init__(self, args):
    method setup_task (line 45) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 53) | def load_dataset(self, split, **kwargs):
    method target_dictionary (line 69) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/cross_lingual_lm.py
  class CrossLingualLMTask (line 30) | class CrossLingualLMTask(FairseqTask):
    method add_args (line 39) | def add_args(parser):
    method __init__ (line 74) | def __init__(self, args, dictionary):
    method _lang_to_id (line 81) | def _lang_to_id(self, languages: str):
    method load_dictionary (line 93) | def load_dictionary(cls, filename):
    method build_dictionary (line 97) | def build_dictionary(
    method target_dictionary (line 109) | def target_dictionary(self):
    method setup_task (line 113) | def setup_task(cls, args, **kwargs):
    method _load_single_lang_dataset (line 122) | def _load_single_lang_dataset(self, split, epoch):
    method load_dataset (line 172) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):

FILE: packages/fairseq-hacked/fairseq/tasks/denoising.py
  class DenoisingTask (line 23) | class DenoisingTask(FairseqTask):
    method add_args (line 29) | def add_args(parser):
    method __init__ (line 121) | def __init__(self, args, dictionary):
    method setup_task (line 130) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 139) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method max_positions (line 198) | def max_positions(self):
    method source_dictionary (line 203) | def source_dictionary(self):
    method target_dictionary (line 208) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/fairseq_task.py
  class FairseqTask (line 18) | class FairseqTask(object):
    method add_args (line 25) | def add_args(parser):
    method __init__ (line 29) | def __init__(self, args):
    method load_dictionary (line 35) | def load_dictionary(cls, filename):
    method build_dictionary (line 44) | def build_dictionary(
    method setup_task (line 68) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 76) | def load_dataset(self, split, combine=False, **kwargs):
    method dataset (line 84) | def dataset(self, split):
    method get_batch_iterator (line 102) | def get_batch_iterator(
    method build_model (line 193) | def build_model(self, args):
    method build_criterion (line 208) | def build_criterion(self, args):
    method build_generator (line 223) | def build_generator(self, args):
    method train_step (line 257) | def train_step(self, sample, model, criterion, optimizer, ignore_grad=...
    method valid_step (line 284) | def valid_step(self, sample, model, criterion):
    method inference_step (line 290) | def inference_step(self, generator, models, sample, prefix_tokens=None):
    method update_step (line 294) | def update_step(self, num_updates):
    method grad_denom (line 299) | def grad_denom(self, sample_sizes, criterion):
    method aggregate_logging_outputs (line 302) | def aggregate_logging_outputs(self, logging_outputs, criterion):
    method max_positions (line 305) | def max_positions(self):
    method source_dictionary (line 310) | def source_dictionary(self):
    method target_dictionary (line 316) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/language_modeling.py
  class LanguageModelingTask (line 23) | class LanguageModelingTask(FairseqTask):
    method add_args (line 53) | def add_args(parser):
    method __init__ (line 84) | def __init__(self, args, dictionary, output_dictionary=None, targets=N...
    method setup_task (line 94) | def setup_task(cls, args, **kwargs):
    method build_model (line 141) | def build_model(self, args):
    method load_dataset (line 152) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method build_dataset_for_inference (line 198) | def build_dataset_for_inference(self, src_tokens, src_lengths):
    method inference_step (line 223) | def inference_step(self, generator, models, sample, prefix_tokens=None):
    method source_dictionary (line 232) | def source_dictionary(self):
    method target_dictionary (line 238) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/legacy_masked_lm.py
  class LegacyMaskedLMTask (line 26) | class LegacyMaskedLMTask(FairseqTask):
    method add_args (line 34) | def add_args(parser):
    method __init__ (line 53) | def __init__(self, args, dictionary):
    method load_dictionary (line 59) | def load_dictionary(cls, filename):
    method build_dictionary (line 63) | def build_dictionary(
    method target_dictionary (line 75) | def target_dictionary(self):
    method setup_task (line 79) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 89) | def load_dataset(self, split, epoch=0, combine=False):

FILE: packages/fairseq-hacked/fairseq/tasks/masked_lm.py
  class MaskedLMTask (line 28) | class MaskedLMTask(FairseqTask):
    method add_args (line 32) | def add_args(parser):
    method __init__ (line 86) | def __init__(self, args, dictionary):
    method setup_task (line 95) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 102) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method build_dataset_for_inference (line 183) | def build_dataset_for_inference(self, src_tokens, src_lengths, sort=Tr...
    method source_dictionary (line 212) | def source_dictionary(self):
    method target_dictionary (line 216) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/multilingual_masked_lm.py
  class MultiLingualMaskedLMTask (line 32) | class MultiLingualMaskedLMTask(FairseqTask):
    method add_args (line 36) | def add_args(parser):
    method __init__ (line 96) | def __init__(self, args, dictionary):
    method setup_task (line 105) | def setup_task(cls, args, **kwargs):
    method _get_whole_word_mask (line 112) | def _get_whole_word_mask(self):
    method _get_sample_prob (line 137) | def _get_sample_prob(self, dataset_lens):
    method load_dataset (line 147) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method build_dataset_for_inference (line 288) | def build_dataset_for_inference(self, src_tokens, src_lengths, sort=Tr...
    method get_batch_iterator (line 316) | def get_batch_iterator(
    method source_dictionary (line 348) | def source_dictionary(self):
    method target_dictionary (line 352) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/multilingual_translation.py
  function _lang_token (line 25) | def _lang_token(lang: str):
  function _lang_token_index (line 29) | def _lang_token_index(dic: Dictionary, lang: str):
  class MultilingualTranslationTask (line 37) | class MultilingualTranslationTask(FairseqTask):
    method add_args (line 63) | def add_args(parser):
    method __init__ (line 95) | def __init__(self, args, dicts, training):
    method setup_task (line 117) | def setup_task(cls, args, **kwargs):
    method prepare (line 122) | def prepare(cls, args, **kargs):
    method get_encoder_langtok (line 167) | def get_encoder_langtok(self, src_lang, tgt_lang):
    method get_decoder_langtok (line 175) | def get_decoder_langtok(self, tgt_lang):
    method alter_dataset_langtok (line 180) | def alter_dataset_langtok(
    method load_dataset (line 216) | def load_dataset(self, split, epoch=0, **kwargs):
    method build_dataset_for_inference (line 260) | def build_dataset_for_inference(self, src_tokens, src_lengths):
    method build_model (line 282) | def build_model(self, args):
    method train_step (line 320) | def train_step(self, sample, model, criterion, optimizer, ignore_grad=...
    method valid_step (line 338) | def valid_step(self, sample, model, criterion):
    method inference_step (line 358) | def inference_step(self, generator, models, sample, prefix_tokens=None):
    method init_logging_output (line 371) | def init_logging_output(self, sample):
    method grad_denom (line 386) | def grad_denom(self, sample_sizes, criterion):
    method aggregate_logging_outputs (line 389) | def aggregate_logging_outputs(
    method source_dictionary (line 424) | def source_dictionary(self):
    method target_dictionary (line 428) | def target_dictionary(self):
    method max_positions (line 431) | def max_positions(self):

FILE: packages/fairseq-hacked/fairseq/tasks/semisupervised_translation.py
  function _get_bt_dataset_key (line 26) | def _get_bt_dataset_key(lang_pair):
  function _get_denoising_dataset_key (line 30) | def _get_denoising_dataset_key(lang_pair):
  function parse_lambda_config (line 35) | def parse_lambda_config(x):
  class SemisupervisedTranslationTask (line 58) | class SemisupervisedTranslationTask(MultilingualTranslationTask):
    method add_args (line 82) | def add_args(parser):
    method __init__ (line 117) | def __init__(self, args, dicts, training):
    method setup_task (line 138) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 142) | def load_dataset(self, split, epoch=0, **kwargs):
    method build_model (line 352) | def build_model(self, args):
    method train_step (line 391) | def train_step(self, sample, model, criterion, optimizer, ignore_grad=...
    method update_step (line 442) | def update_step(self, num_updates):
    method aggregate_logging_outputs (line 472) | def aggregate_logging_outputs(self, logging_outputs, criterion):

FILE: packages/fairseq-hacked/fairseq/tasks/sentence_prediction.py
  class SentencePredictionTask (line 32) | class SentencePredictionTask(FairseqTask):
    method add_args (line 41) | def add_args(parser):
    method __init__ (line 74) | def __init__(self, args, data_dictionary, label_dictionary):
    method load_dictionary (line 88) | def load_dictionary(cls, args, filename, source=True):
    method setup_task (line 99) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 119) | def load_dataset(self, split, combine=False, **kwargs):
    method build_model (line 213) | def build_model(self, args):
    method max_positions (line 224) | def max_positions(self):
    method source_dictionary (line 228) | def source_dictionary(self):
    method target_dictionary (line 232) | def target_dictionary(self):
    method label_dictionary (line 236) | def label_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/sentence_ranking.py
  class SentenceRankingTask (line 29) | class SentenceRankingTask(FairseqTask):
    method add_args (line 38) | def add_args(parser):
    method __init__ (line 62) | def __init__(self, args, dictionary):
    method load_dictionary (line 67) | def load_dictionary(cls, args, filename, source=True):
    method setup_task (line 78) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 90) | def load_dataset(self, split, combine=False, **kwargs):
    method build_model (line 179) | def build_model(self, args):
    method max_positions (line 190) | def max_positions(self):
    method source_dictionary (line 194) | def source_dictionary(self):
    method target_dictionary (line 198) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/translation.py
  function load_langpair_dataset (line 24) | def load_langpair_dataset(
  class TranslationTask (line 129) | class TranslationTask(FairseqTask):
    method add_args (line 151) | def add_args(parser):
    method __init__ (line 180) | def __init__(self, args, src_dict, tgt_dict):
    method setup_task (line 186) | def setup_task(cls, args, **kwargs):
    method load_dataset (line 232) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method build_dataset_for_inference (line 263) | def build_dataset_for_inference(self, src_tokens, src_lengths):
    method max_positions (line 266) | def max_positions(self):
    method source_dictionary (line 271) | def source_dictionary(self):
    method target_dictionary (line 276) | def target_dictionary(self):

FILE: packages/fairseq-hacked/fairseq/tasks/translation_from_pretrained_xlm.py
  class TranslationFromPretrainedXLMTask (line 13) | class TranslationFromPretrainedXLMTask(TranslationTask):
    method load_dictionary (line 25) | def load_dictionary(cls, filename):

FILE: packages/fairseq-hacked/fairseq/tasks/translation_lev.py
  class TranslationLevenshteinTask (line 14) | class TranslationLevenshteinTask(TranslationTask):
    method add_args (line 21) | def add_args(parser):
    method load_dataset (line 30) | def load_dataset(self, split, epoch=0, combine=False, **kwargs):
    method inject_noise (line 54) | def inject_noise(self, target_tokens):
    method build_generator (line 127) | def build_generator(self, args):
    method train_step (line 137) | def train_step(self,
    method valid_step (line 151) | def valid_step(self, sample, model, criterion):

FILE: packages/fairseq-hacked/fairseq/tasks/translation_moe.py
  class TranslationMoETask (line 14) | class TranslationMoETask(TranslationTask):
    method add_args (line 39) | def add_args(parser):
    method __init__ (line 57) | def __init__(self, args, src_dict, tgt_dict):
    method build_model (line 83) | def build_model(self, args):
    method expert_index (line 116) | def expert_index(self, i):
    method _get_loss (line 119) | def _get_loss(self, sample, model, criterion):
    method train_step (line 190) | def train_step(self, sample, model, criterion, optimizer, ignore_grad=...
    method valid_step (line 198) | def valid_step(self, sample, model, criterion):
    method inference_step (line 204) | def inference_step(
    method aggregate_logging_outputs (line 216) | def aggregate_logging_outputs(self, logging_outputs, criterion):

FILE: packages/fairseq-hacked/fairseq/tokenizer.py
  function tokenize_line (line 11) | def tokenize_line(line):

FILE: packages/fairseq-hacked/fairseq/trainer.py
  class Trainer (line 23) | class Trainer(object):
    method __init__ (line 33) | def __init__(self, args, task, model, criterion, dummy_batch=None, oom...
    method init_meters (line 66) | def init_meters(self, args):
    method criterion (line 85) | def criterion(self):
    method model (line 100) | def model(self):
    method optimizer (line 111) | def optimizer(self):
    method lr_scheduler (line 117) | def lr_scheduler(self):
    method _build_optimizer (line 122) | def _build_optimizer(self):
    method save_checkpoint (line 155) | def save_checkpoint(self, filename, extra_state):
    method load_checkpoint (line 171) | def load_checkpoint(
    method get_train_iterator (line 253) | def get_train_iterator(
    method train_step (line 286) | def train_step(self, samples, dummy_batch=False, raise_oom=False):
    method valid_step (line 498) | def valid_step(self, sample, raise_oom=False):
    method dummy_train_step (line 563) | def dummy_train_step(self, dummy_batch):
    method handle_ooms (line 568) | def handle_ooms(self, number_of_ooms):
    method zero_grad (line 577) | def zero_grad(self):
    method clear_buffered_stats (line 580) | def clear_buffered_stats(self):
    method lr_step (line 583) | def lr_step(self, epoch, val_loss=None):
    method lr_step_update (line 589) | def lr_step_update(self):
    method get_lr (line 593) | def get_lr(self):
    method get_model (line 597) | def get_model(self):
    method get_criterion (line 601) | def get_criterion(self):
    method get_meter (line 605) | def get_meter(self, name):
    method get_num_updates (line 611) | def get_num_updates(self):
    method set_num_updates (line 615) | def set_num_updates(self, num_updates):
    method _prepare_sample (line 620) | def _prepare_sample(self, sample):
    method _set_seed (line 637) | def _set_seed(self):
    method _sync_stats (line 645) | def _sync_stats(self):
    method _log_oom (line 654) | def _log_oom(self, exc):

FILE: packages/fairseq-hacked/fairseq/utils.py
  function load_ensemble_for_inference (line 23) | def load_ensemble_for_inference(filenames, task, model_arg_overrides=None):
  function apply_to_sample (line 35) | def apply_to_sample(f, sample):
  function move_to_cuda (line 52) | def move_to_cuda(sample):
  function _get_full_incremental_state_key (line 62) | def _get_full_incremental_state_key(module_instance, key):
  function get_incremental_state (line 76) | def get_incremental_state(module, incremental_state, key):
  function set_incremental_state (line 84) | def set_incremental_state(module, incremental_state, key, value):
  function load_align_dict (line 91) | def load_align_dict(replace_unk):
  function print_embed_overlap (line 108) | def print_embed_overlap(embed_dict, vocab_dict):
  function parse_embedding (line 115) | def parse_embedding(embed_path):
  function load_embedding (line 137) | def load_embedding(embed_dict, vocab, embedding):
  function replace_unk (line 145) | def replace_unk(hypo_str, src_str, alignment, align_dict, unk):
  function post_process_prediction (line 160) | def post_process_prediction(
  function make_positions (line 175) | def make_positions(tensor, padding_idx, onnx_trace=False):
  function strip_pad (line 188) | def strip_pad(tensor, pad):
  function buffered_arange (line 192) | def buffered_arange(max):
  function convert_padding_direction (line 200) | def convert_padding_direction(
  function item (line 224) | def item(tensor):
  function clip_grad_norm_ (line 232) | def clip_grad_norm_(tensor, max_norm):
  function fill_with_neg_inf (line 240) | def fill_with_neg_inf(t):
  function resolve_max_positions (line 245) | def resolve_max_positions(*args):
  function import_user_module (line 281) | def import_user_module(args):
  function softmax (line 299) | def softmax(x, dim, onnx_trace=False):
  function log_softmax (line 306) | def log_softmax(x, dim, onnx_trace=False):
  function get_perplexity (line 313) | def get_perplexity(loss):
  function deprecation_warning (line 320) | def deprecation_warning(message, stacklevel=3):
  function get_activation_fn (line 325) | def get_activation_fn(activation: str) -> Callable:
  function get_available_activation_fns (line 346) | def get_available_activation_fns() -> List:
  function eval (line 358) | def eval(model):
  function has_parameters (line 365) | def has_parameters(module):
  function set_torch_seed (line 373) | def set_torch_seed(seed):
  function parse_alignment (line 381) | def parse_alignment(line):
  function get_token_to_word_mapping (line 402) | def get_token_to_word_mapping(tokens, exclude_list):
  function extract_hard_alignment (line 410) | def extract_hard_alignment(attn, src_sent, tgt_sent, pad, eos):
  function new_arange (line 430) | def new_arange(x, *size):

FILE: packages/fairseq-hacked/generate.py
  function main (line 16) | def main(args):
  function cli_main (line 243) | def cli_main():

FILE: packages/fairseq-hacked/interactive.py
  function buffered_read (line 23) | def buffered_read(input, buffer_size):
  function make_batches (line 36) | def make_batches(lines, args, task, max_positions, encode_fn):
  function main (line 58) | def main(args):
  function cli_main (line 190) | def cli_main():

FILE: packages/fairseq-hacked/preprocess.py
  function main (line 22) | def main(args):
  function binarize (line 320) | def binarize(args, filename, vocab, output_prefix, lang, offset, end, ap...
  function binarize_alignments (line 337) | def binarize_alignments(args, filename, parse_alignment, output_prefix, ...
  function dataset_dest_prefix (line 354) | def dataset_dest_prefix(args, output_prefix, lang):
  function dataset_dest_file (line 366) | def dataset_dest_file(args, output_prefix, lang, extension):
  function get_offsets (line 371) | def get_offsets(input_file, num_workers):
  function cli_main (line 375) | def cli_main():

FILE: packages/fairseq-hacked/score.py
  function get_parser (line 18) | def get_parser():
  function main (line 37) | def main():

FILE: packages/fairseq-hacked/scripts/average_checkpoints.py
  function average_checkpoints (line 14) | def average_checkpoints(inputs):
  function last_n_checkpoints (line 70) | def last_n_checkpoints(paths, n, update_based, upper_bound=None):
  function main (line 93) | def main():

FILE: packages/fairseq-hacked/scripts/build_sym_alignment.py
  function main (line 29) | def main():

FILE: packages/fairseq-hacked/scripts/compare_namespaces.py
  function main (line 7) | def main():

FILE: packages/fairseq-hacked/scripts/count_docs.py
  function main (line 18) | def main():

FILE: packages/fairseq-hacked/scripts/read_binarized.py
  function get_parser (line 12) | def get_parser():
  function main (line 26) | def main():

FILE: packages/fairseq-hacked/scripts/rm_pt.py
  function parse_checkpoints (line 19) | def parse_checkpoints(files):
  function last_n_checkpoints (line 32) | def last_n_checkpoints(files, n):
  function every_n_checkpoints (line 37) | def every_n_checkpoints(files, n):
  function main (line 42) | def main():

FILE: packages/fairseq-hacked/scripts/shard_docs.py
  function main (line 15) | def main():

FILE: packages/fairseq-hacked/scripts/split_train_valid_docs.py
  function main (line 16) | def main():

FILE: packages/fairseq-hacked/scripts/spm_decode.py
  function main (line 15) | def main():

FILE: packages/fairseq-hacked/scripts/spm_encode.py
  function main (line 17) | def main():

FILE: packages/fairseq-hacked/scripts/wav2vec_featurize.py
  function read_audio (line 26) | def read_audio(fname):
  class PretrainedWav2VecModel (line 35) | class PretrainedWav2VecModel(nn.Module):
    method __init__ (line 36) | def __init__(self, fname):
    method forward (line 47) | def forward(self, x):
  class EmbeddingWriterConfig (line 56) | class EmbeddingWriterConfig(argparse.ArgumentParser):
    method __init__ (line 57) | def __init__(self):
  class Prediction (line 83) | class Prediction:
    method __init__ (line 86) | def __init__(self, fname, gpu=0):
    method __call__ (line 90) | def __call__(self, x):
  class H5Writer (line 98) | class H5Writer:
    method __init__ (line 101) | def __init__(self, fname):
    method write (line 105) | def write(self, data):
  class EmbeddingDatasetWriter (line 114) | class EmbeddingDatasetWriter(object):
    method __init__ (line 126) | def __init__(
    method _progress (line 154) | def _progress(self, iterable, **kwargs):
    method require_output_path (line 159) | def require_output_path(self, fname=None):
    method input_path (line 164) | def input_path(self):
    method output_path (line 168) | def output_path(self):
    method get_input_path (line 171) | def get_input_path(self, fname=None):
    method get_output_path (line 176) | def get_output_path(self, fname=None):
    method copy_labels (line 181) | def copy_labels(self):
    method input_fnames (line 193) | def input_fnames(self):
    method __len__ (line 196) | def __len__(self):
    method write_features (line 199) | def write_features(self):
    method __repr__ (line 219) | def __repr__(self):

FILE: packages/fairseq-hacked/scripts/wav2vec_manifest.py
  function get_parser (line 17) | def get_parser():
  function main (line 46) | def main(args):

FILE: packages/fairseq-hacked/setup.py
  class NumpyExtension (line 26) | class NumpyExtension(Extension):
    method __init__ (line 29) | def __init__(self, *args, **kwargs):
    method include_dirs (line 34) | def include_dirs(self):
    method include_dirs (line 40) | def include_dirs(self, dirs):

FILE: packages/fairseq-hacked/tests/speech_recognition/asr_test_base.py
  function get_dummy_dictionary (line 32) | def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE):
  class DummyTask (line 40) | class DummyTask(FairseqTask):
    method __init__ (line 41) | def __init__(self, args):
    method target_dictionary (line 49) | def target_dictionary(self):
  function get_dummy_task_and_parser (line 53) | def get_dummy_task_and_parser():
  function get_dummy_input (line 70) | def get_dummy_input(T=100, D=80, B=5, K=100):
  function get_dummy_encoder_output (line 104) | def get_dummy_encoder_output(encoder_out_shape=(100, 80, 5)):
  function _current_postion_info (line 126) | def _current_postion_info():
  function check_encoder_output (line 134) | def check_encoder_output(encoder_output, batch_size=None):
  function check_decoder_output (line 201) | def check_decoder_output(decoder_output):
  class TestBaseFairseqModelBase (line 228) | class TestBaseFairseqModelBase(unittest.TestCase):
    method setUpClass (line 235) | def setUpClass(cls):
    method setUpModel (line 240) | def setUpModel(self, model):
    method setupInput (line 244) | def setupInput(self):
    method setUp (line 247) | def setUp(self):
  class TestFairseqEncoderDecoderModelBase (line 253) | class TestFairseqEncoderDecoderModelBase(TestBaseFairseqModelBase):
    method setUpClass (line 260) | def setUpClass(cls):
    method setUpModel (line 265) | def setUpModel(self, model_cls, extra_args_setters=None):
    method setUpInput (line 281) | def setUpInput(self, input=None):
    method setUp (line 284) | def setUp(self):
    method test_forward (line 287) | def test_forward(self):
    method test_get_normalized_probs (line 297) | def test_get_normalized_probs(self):
  class TestFairseqEncoderModelBase (line 316) | class TestFairseqEncoderModelBase(TestBaseFairseqModelBase):
    method setUpClass (line 322) | def setUpClass(cls):
    method setUpModel (line 327) | def setUpModel(self, model_cls, extra_args_setters=None):
    method setUpInput (line 342) | def setUpInput(self, input=None):
    method setUp (line 348) | def setUp(self):
    method test_forward (line 351) | def test_forward(self):
    method test_get_normalized_probs (line 365) | def test_get_normalized_probs(self):
  class TestFairseqEncoderBase (line 384) | class TestFairseqEncoderBase(unittest.TestCase):
    method setUpClass (line 390) | def setUpClass(cls):
    method setUpEncoder (line 395) | def setUpEncoder(self, encoder):
    method setUpInput (line 402) | def setUpInput(self, input=None):
    method setUp (line 408) | def setUp(self):
    method test_forward (line 412) | def test_forward(self):
  class TestFairseqDecoderBase (line 423) | class TestFairseqDecoderBase(unittest.TestCase):
    method setUpClass (line 429) | def setUpClass(cls):
    method setUpDecoder (line 434) | def setUpDecoder(self, decoder):
    method setUpInput (line 441) | def setUpInput(self, input=None):
    method setUpPrevOutputTokens (line 444) | def setUpPrevOutputTokens(self, tokens=None):
    method setUp (line 451) | def setUp(self):
    method test_forward (line 456) | def test_forward(self):
  class DummyEncoderModel (line 472) | class DummyEncoderModel(FairseqEncoderModel):
    method __init__ (line 473) | def __init__(self, encoder):
    method build_model (line 477) | def build_model(cls, args, task):
    method get_logits (line 480) | def get_logits(self, net_output):
  class DummyEncoder (line 488) | class DummyEncoder(FairseqEncoder):
    method __init__ (line 489) | def __init__(self):
    method forward (line 492) | def forward(self, src_tokens, src_lengths):
  class CrossEntropyCriterionTestBase (line 497) | class CrossEntropyCriterionTestBase(unittest.TestCase):
    method setUpClass (line 499) | def setUpClass(cls):
    method setUpArgs (line 504) | def setUpArgs(self):
    method setUp (line 510) | def setUp(self):
    method get_src_tokens (line 515) | def get_src_tokens(self, correct_prediction, aggregate):
    method get_target (line 534) | def get_target(self, soft_target):
    method get_test_sample (line 543) | def get_test_sample(self, correct, soft_target, aggregate):

FILE: packages/fairseq-hacked/tests/speech_recognition/test_collaters.py
  class TestSeq2SeqCollator (line 14) | class TestSeq2SeqCollator(unittest.TestCase):
    method test_collate (line 15) | def test_collate(self):
    method assertTensorEqual (line 52) | def assertTensorEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/speech_recognition/test_cross_entropy.py
  class CrossEntropyWithAccCriterionTest (line 13) | class CrossEntropyWithAccCriterionTest(CrossEntropyCriterionTestBase):
    method setUp (line 14) | def setUp(self):
    method test_cross_entropy_all_correct (line 18) | def test_cross_entropy_all_correct(self):
    method test_cross_entropy_all_wrong (line 28) | def test_cross_entropy_all_wrong(self):

FILE: packages/fairseq-hacked/tests/speech_recognition/test_vggtransformer.py
  class VGGTransformerModelTest_mid (line 25) | class VGGTransformerModelTest_mid(TestFairseqEncoderDecoderModelBase):
    method setUp (line 26) | def setUp(self):
  class VGGTransformerModelTest_big (line 44) | class VGGTransformerModelTest_big(TestFairseqEncoderDecoderModelBase):
    method setUp (line 45) | def setUp(self):
  class VGGTransformerModelTest_base (line 63) | class VGGTransformerModelTest_base(TestFairseqEncoderDecoderModelBase):
    method setUp (line 64) | def setUp(self):
  class VGGTransformerEncoderTest (line 82) | class VGGTransformerEncoderTest(TestFairseqEncoderBase):
    method setUp (line 83) | def setUp(self):
    method test_forward (line 88) | def test_forward(self):
  class TransformerDecoderTest (line 125) | class TransformerDecoderTest(TestFairseqDecoderBase):
    method setUp (line 126) | def setUp(self):

FILE: packages/fairseq-hacked/tests/test_average_checkpoints.py
  class ModelWithSharedParameter (line 20) | class ModelWithSharedParameter(nn.Module):
    method __init__ (line 21) | def __init__(self):
    method forward (line 32) | def forward(self, input):
  class TestAverageCheckpoints (line 36) | class TestAverageCheckpoints(unittest.TestCase):
    method test_average_checkpoints (line 37) | def test_average_checkpoints(self):
    method test_average_checkpoints_with_shared_parameters (line 90) | def test_average_checkpoints_with_shared_parameters(self):

FILE: packages/fairseq-hacked/tests/test_backtranslation_dataset.py
  class TestBacktranslationDataset (line 20) | class TestBacktranslationDataset(unittest.TestCase):
    method setUp (line 21) | def setUp(self):
    method _backtranslation_dataset_helper (line 36) | def _backtranslation_dataset_helper(
    method test_backtranslation_dataset_no_eos_in_output_src (line 99) | def test_backtranslation_dataset_no_eos_in_output_src(self):
    method test_backtranslation_dataset_with_eos_in_output_src (line 104) | def test_backtranslation_dataset_with_eos_in_output_src(self):
    method test_backtranslation_dataset_no_eos_in_input_src (line 109) | def test_backtranslation_dataset_no_eos_in_input_src(self):
    method assertTensorEqual (line 114) | def assertTensorEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_binaries.py
  class TestTranslation (line 26) | class TestTranslation(unittest.TestCase):
    method test_fconv (line 27) | def test_fconv(self):
    method test_raw (line 35) | def test_raw(self):
    method test_fp16 (line 45) | def test_fp16(self):
    method test_memory_efficient_fp16 (line 53) | def test_memory_efficient_fp16(self):
    method test_update_freq (line 63) | def test_update_freq(self):
    method test_max_positions (line 73) | def test_max_positions(self):
    method test_generation (line 99) | def test_generation(self):
    method test_lstm (line 143) | def test_lstm(self):
    method test_lstm_bidirectional (line 166) | def test_lstm_bidirectional(self):
    method test_transformer (line 192) | def test_transformer(self):
    method test_transformer_cross_self_attention (line 214) | def test_transformer_cross_self_attention(self):
    method test_lightconv (line 243) | def test_lightconv(self):
    method test_dynamicconv (line 264) | def test_dynamicconv(self):
    method test_cmlm_transformer (line 285) | def test_cmlm_transformer(self):
    method test_levenshtein_transformer (line 318) | def test_levenshtein_transformer(self):
    method test_nonautoregressive_transformer (line 350) | def test_nonautoregressive_transformer(self):
    method test_iterative_nonautoregressive_transformer (line 386) | def test_iterative_nonautoregressive_transformer(self):
    method test_insertion_transformer (line 424) | def test_insertion_transformer(self):
    method test_mixture_of_experts (line 454) | def test_mixture_of_experts(self):
    method test_alignment (line 495) | def test_alignment(self):
  class TestStories (line 523) | class TestStories(unittest.TestCase):
    method test_fconv_self_att_wp (line 524) | def test_fconv_self_att_wp(self):
  class TestLanguageModeling (line 574) | class TestLanguageModeling(unittest.TestCase):
    method test_fconv_lm (line 575) | def test_fconv_lm(self):
    method test_transformer_lm (line 596) | def test_transformer_lm(self):
    method test_lightconv_lm (line 620) | def test_lightconv_lm(self):
  class TestMaskedLanguageModel (line 642) | class TestMaskedLanguageModel(unittest.TestCase):
    method test_legacy_masked_lm (line 643) | def test_legacy_masked_lm(self):
    method _test_pretrained_masked_lm_for_translation (line 650) | def _test_pretrained_masked_lm_for_translation(self, learned_pos_emb, ...
    method test_pretrained_masked_lm_for_translation_learned_pos_emb (line 706) | def test_pretrained_masked_lm_for_translation_learned_pos_emb(self):
    method test_pretrained_masked_lm_for_translation_sinusoidal_pos_emb (line 709) | def test_pretrained_masked_lm_for_translation_sinusoidal_pos_emb(self):
    method test_pretrained_masked_lm_for_translation_encoder_only (line 712) | def test_pretrained_masked_lm_for_translation_encoder_only(self):
  function train_legacy_masked_language_model (line 716) | def train_legacy_masked_language_model(data_dir, arch, extra_args=()):
  class TestCommonOptions (line 780) | class TestCommonOptions(unittest.TestCase):
    method test_optimizers (line 781) | def test_optimizers(self):
  function create_dummy_data (line 811) | def create_dummy_data(data_dir, num_examples=1000, maxlen=20, alignment=...
  function preprocess_translation_data (line 855) | def preprocess_translation_data(data_dir, extra_flags=None):
  function train_translation_model (line 881) | def train_translation_model(
  function generate_main (line 934) | def generate_main(data_dir, extra_flags=None):
  function preprocess_lm_data (line 972) | def preprocess_lm_data(data_dir):
  function train_language_model (line 990) | def train_language_model(data_dir, arch, extra_flags=None, run_validatio...
  function eval_lm_main (line 1047) | def eval_lm_main(data_dir):

FILE: packages/fairseq-hacked/tests/test_bmuf.py
  class Model (line 17) | class Model(nn.Module):
    method __init__ (line 18) | def __init__(self, input_size, output_size):
    method forward (line 22) | def forward(self, input):
  function setup_model_loss_criterion (line 27) | def setup_model_loss_criterion(args, rank, is_cuda):
  function train_step (line 46) | def train_step(input, target, model, loss_fn, optimizer):
  function single_gpu_training (line 55) | def single_gpu_training(args, rank, iterations, shared_results):
  function setup_args (line 82) | def setup_args():
  class TestBMUF (line 108) | class TestBMUF(unittest.TestCase):
    method bmuf_process (line 109) | def bmuf_process(self, args, iterations):
    method test_bmuf_sync (line 127) | def test_bmuf_sync(self):
    method test_warmup_sync (line 133) | def test_warmup_sync(self):
    method test_warmup_sync_bmuf_sync (line 140) | def test_warmup_sync_bmuf_sync(self):
    method assertAlmostEqual (line 149) | def assertAlmostEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_character_token_embedder.py
  class TestCharacterTokenEmbedder (line 13) | class TestCharacterTokenEmbedder(unittest.TestCase):
    method test_character_token_embedder (line 14) | def test_character_token_embedder(self):
    method assertAlmostEqual (line 42) | def assertAlmostEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_concat_dataset.py
  class TestConcatDataset (line 14) | class TestConcatDataset(unittest.TestCase):
    method setUp (line 15) | def setUp(self):
    method test_concat_dataset_basics (line 42) | def test_concat_dataset_basics(self):

FILE: packages/fairseq-hacked/tests/test_convtbc.py
  class TestConvTBC (line 12) | class TestConvTBC(unittest.TestCase):
    method test_convtbc (line 13) | def test_convtbc(self):
    method assertAlmostEqual (line 47) | def assertAlmostEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_dictionary.py
  class TestDictionary (line 14) | class TestDictionary(unittest.TestCase):
    method test_finalize (line 15) | def test_finalize(self):

FILE: packages/fairseq-hacked/tests/test_iterators.py
  class TestIterators (line 11) | class TestIterators(unittest.TestCase):
    method test_counting_iterator (line 12) | def test_counting_iterator(self):

FILE: packages/fairseq-hacked/tests/test_label_smoothing.py
  class TestLabelSmoothing (line 20) | class TestLabelSmoothing(unittest.TestCase):
    method setUp (line 21) | def setUp(self):
    method test_nll_loss (line 63) | def test_nll_loss(self):
    method test_padding (line 76) | def test_padding(self):
    method test_reduction (line 95) | def test_reduction(self):
    method test_zero_eps (line 102) | def test_zero_eps(self):
    method assertAlmostEqual (line 114) | def assertAlmostEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_memory_efficient_fp16.py
  class TestMemoryEfficientFP16 (line 15) | class TestMemoryEfficientFP16(unittest.TestCase):
    method test_load_state_dict (line 16) | def test_load_state_dict(self):

FILE: packages/fairseq-hacked/tests/test_multi_corpus_sampled_dataset.py
  class TestMultiCorpusSampledDataset (line 16) | class TestMultiCorpusSampledDataset(unittest.TestCase):
    method setUp (line 17) | def setUp(self):
    method _test_sample_helper (line 44) | def _test_sample_helper(
    method test_multi_corpus_sampled_dataset_uniform_sample (line 77) | def test_multi_corpus_sampled_dataset_uniform_sample(self):
    method test_multi_corpus_sampled_dataset_weighted_sample (line 80) | def test_multi_corpus_sampled_dataset_weighted_sample(self):

FILE: packages/fairseq-hacked/tests/test_multihead_attention.py
  class TestMultiheadAttention (line 11) | class TestMultiheadAttention(unittest.TestCase):
    method test_append_prev_key_padding_mask (line 12) | def test_append_prev_key_padding_mask(self):

FILE: packages/fairseq-hacked/tests/test_noising.py
  class TestDataNoising (line 21) | class TestDataNoising(unittest.TestCase):
    method _get_test_data_with_bpe_cont_marker (line 22) | def _get_test_data_with_bpe_cont_marker(self, append_eos=True):
    method _get_test_data_with_bpe_end_marker (line 57) | def _get_test_data_with_bpe_end_marker(self, append_eos=True):
    method _get_test_data_with_word_vocab (line 93) | def _get_test_data_with_word_vocab(self, append_eos=True):
    method _convert_src_tokens_to_tensor (line 122) | def _convert_src_tokens_to_tensor(
    method assert_eos_at_end (line 140) | def assert_eos_at_end(self, x, x_len, eos):
    method assert_word_dropout_correct (line 152) | def assert_word_dropout_correct(self, x, x_noised, x_len, l_noised):
    method test_word_dropout_with_eos (line 159) | def test_word_dropout_with_eos(self):
    method assert_word_blanking_correct (line 170) | def assert_word_blanking_correct(self, x, x_noised, x_len, l_noised, u...
    method test_word_blank_with_eos (line 180) | def test_word_blank_with_eos(self):
    method generate_unchanged_shuffle_map (line 191) | def generate_unchanged_shuffle_map(self, length):
    method assert_word_shuffle_matches_expected (line 194) | def assert_word_shuffle_matches_expected(
    method test_word_shuffle_with_eos (line 246) | def test_word_shuffle_with_eos(self):
    method test_word_shuffle_with_eos_nonbpe (line 277) | def test_word_shuffle_with_eos_nonbpe(self):
    method test_word_shuffle_without_eos (line 309) | def test_word_shuffle_without_eos(self):
    method test_word_shuffle_without_eos_with_bpe_end_marker (line 341) | def test_word_shuffle_without_eos_with_bpe_end_marker(self):
    method assert_no_eos_at_end (line 375) | def assert_no_eos_at_end(self, x, x_len, eos):
    method test_word_dropout_without_eos (line 386) | def test_word_dropout_without_eos(self):
    method test_word_blank_without_eos (line 398) | def test_word_blank_without_eos(self):
    method _get_noising_dataset_batch (line 410) | def _get_noising_dataset_batch(
    method test_noising_dataset_with_eos (line 447) | def test_noising_dataset_with_eos(self):
    method test_noising_dataset_without_eos (line 479) | def test_noising_dataset_without_eos(self):
    method assertTensorEqual (line 519) | def assertTensorEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_reproducibility.py
  class TestReproducibility (line 16) | class TestReproducibility(unittest.TestCase):
    method _test_reproducibility (line 17) | def _test_reproducibility(self, name, extra_flags=None):
    method test_reproducibility (line 85) | def test_reproducibility(self):
    method test_reproducibility_fp16 (line 88) | def test_reproducibility_fp16(self):
    method test_reproducibility_memory_efficient_fp16 (line 93) | def test_reproducibility_memory_efficient_fp16(self):

FILE: packages/fairseq-hacked/tests/test_resampling_dataset.py
  class TestResamplingDataset (line 14) | class TestResamplingDataset(unittest.TestCase):
    method setUp (line 15) | def setUp(self):
    method _test_common (line 23) | def _test_common(self, resampling_dataset, iters):
    method test_resampling_dataset_batch_by_size_false (line 66) | def test_resampling_dataset_batch_by_size_false(self):
    method test_resampling_dataset_batch_by_size_true (line 84) | def test_resampling_dataset_batch_by_size_true(self):

FILE: packages/fairseq-hacked/tests/test_sequence_generator.py
  class TestSequenceGeneratorBase (line 16) | class TestSequenceGeneratorBase(unittest.TestCase):
    method assertHypoTokens (line 17) | def assertHypoTokens(self, hypo, tokens):
    method assertHypoScore (line 20) | def assertHypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0):
    method assertAlmostEqual (line 29) | def assertAlmostEqual(self, t1, t2):
    method assertTensorEqual (line 33) | def assertTensorEqual(self, t1, t2):
  class TestSequenceGenerator (line 38) | class TestSequenceGenerator(TestSequenceGeneratorBase):
    method setUp (line 39) | def setUp(self):
    method test_with_normalization (line 52) | def test_with_normalization(self):
    method test_without_normalization (line 69) | def test_without_normalization(self):
    method test_with_lenpen_favoring_short_hypos (line 90) | def test_with_lenpen_favoring_short_hypos(self):
    method test_with_lenpen_favoring_long_hypos (line 108) | def test_with_lenpen_favoring_long_hypos(self):
    method test_maxlen (line 126) | def test_maxlen(self):
  class TestDiverseBeamSearch (line 144) | class TestDiverseBeamSearch(TestSequenceGeneratorBase):
    method setUp (line 145) | def setUp(self):
    method test_diverse_beam_search (line 206) | def test_diverse_beam_search(self):
  class TestTopPSamplingSearch (line 235) | class TestTopPSamplingSearch(TestSequenceGeneratorBase):
    method setUp (line 236) | def setUp(self):
    method test_topp_sampling_search_low_prob (line 300) | def test_topp_sampling_search_low_prob(self):
    method test_topp_sampling_search_high_prob (line 328) | def test_topp_sampling_search_high_prob(self):
    method hypoTokens (line 383) | def hypoTokens(self, hypo, tokens):
    method hypoScore (line 386) | def hypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0):
    method almostEqual (line 397) | def almostEqual(self, t1, t2):
    method tensorEqual (line 400) | def tensorEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_sequence_scorer.py
  class TestSequenceScorer (line 16) | class TestSequenceScorer(unittest.TestCase):
    method test_sequence_scorer (line 17) | def test_sequence_scorer(self):
    method assertHypoTokens (line 100) | def assertHypoTokens(self, hypo, tokens):
    method assertHypoScore (line 103) | def assertHypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0):
    method assertAlmostEqual (line 112) | def assertAlmostEqual(self, t1, t2):
    method assertTensorEqual (line 116) | def assertTensorEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/test_sparse_multihead_attention.py
  class TestSparseMultiheadAttention (line 11) | class TestSparseMultiheadAttention(unittest.TestCase):
    method test_sparse_multihead_attention (line 12) | def test_sparse_multihead_attention(self):

FILE: packages/fairseq-hacked/tests/test_token_block_dataset.py
  class TestTokenBlockDataset (line 15) | class TestTokenBlockDataset(unittest.TestCase):
    method _build_dataset (line 16) | def _build_dataset(self, data, **kwargs):
    method test_eos_break_mode (line 21) | def test_eos_break_mode(self):
    method test_block_break_mode (line 42) | def test_block_break_mode(self):
    method test_complete_break_mode (line 54) | def test_complete_break_mode(self):

FILE: packages/fairseq-hacked/tests/test_train.py
  function mock_trainer (line 16) | def mock_trainer(epoch, num_updates, iterations_in_epoch):
  function mock_dict (line 29) | def mock_dict():
  function get_trainer_and_epoch_itr (line 37) | def get_trainer_and_epoch_itr(epoch, epoch_size, num_updates, iterations...
  class TestLoadCheckpoint (line 59) | class TestLoadCheckpoint(unittest.TestCase):
    method setUp (line 60) | def setUp(self):
    method test_load_partial_checkpoint (line 75) | def test_load_partial_checkpoint(self):
    method test_load_full_checkpoint (line 105) | def test_load_full_checkpoint(self):
    method test_load_no_checkpoint (line 117) | def test_load_no_checkpoint(self):
    method tearDown (line 130) | def tearDown(self):

FILE: packages/fairseq-hacked/tests/test_utils.py
  class TestUtils (line 13) | class TestUtils(unittest.TestCase):
    method test_convert_padding_direction (line 14) | def test_convert_padding_direction(self):
    method test_make_positions (line 32) | def test_make_positions(self):
    method assertAlmostEqual (line 54) | def assertAlmostEqual(self, t1, t2):

FILE: packages/fairseq-hacked/tests/utils.py
  function dummy_dictionary (line 20) | def dummy_dictionary(vocab_size, prefix="token_"):
  function dummy_dataloader (line 29) | def dummy_dataloader(
  function sequence_generator_setup (line 50) | def sequence_generator_setup():
  class TestDataset (line 152) | class TestDataset(torch.utils.data.Dataset):
    method __init__ (line 153) | def __init__(self, data):
    method __getitem__ (line 158) | def __getitem__(self, index):
    method __len__ (line 161) | def __len__(self):
  class TestTranslationTask (line 165) | class TestTranslationTask(FairseqTask):
    method __init__ (line 166) | def __init__(self, args, src_dict, tgt_dict, model):
    method setup_task (line 173) | def setup_task(cls, args, src_dict=None, tgt_dict=None, model=None):
    method build_model (line 176) | def build_model(self, args):
    method source_dictionary (line 180) | def source_dictionary(self):
    method target_dictionary (line 184) | def target_dictionary(self):
  class TestModel (line 188) | class TestModel(FairseqEncoderDecoderModel):
    method __init__ (line 189) | def __init__(self, encoder, decoder):
    method build_model (line 193) | def build_model(cls, args, task):
  class TestEncoder (line 199) | class TestEncoder(FairseqEncoder):
    method __init__ (line 200) | def __init__(self, args, dictionary):
    method forward (line 204) | def forward(self, src_tokens, src_lengths=None, **kwargs):
    method reorder_encoder_out (line 207) | def reorder_encoder_out(self, encoder_out, new_order):
  class TestIncrementalDecoder (line 211) | class TestIncrementalDecoder(FairseqIncrementalDecoder):
    method __init__ (line 212) | def __init__(self, args, dictionary):
    method forward (line 218) | def forward(self, prev_output_tokens, encoder_out=None, incremental_st...
    method get_normalized_probs (line 259) | def get_normalized_probs(self, net_output, log_probs, _):
    method max_positions (line 267) | def max_positions(self):

FILE: packages/fairseq-hacked/train.py
  function main (line 30) | def main(args, init_distributed=False):
  function train (line 125) | def train(args, trainer, task, epoch_itr):
  function get_training_stats (line 204) | def get_training_stats(trainer):
  function validate (line 229) | def validate(args, trainer, task, epoch_itr, subsets):
  function get_valid_stats (line 290) | def get_valid_stats(trainer, args, extra_meters=None):
  function distributed_main (line 320) | def distributed_main(i, args, start_rank=0):
  function cli_main (line 327) | def cli_main():

FILE: packages/fairseq-hacked/validate.py
  function main (line 13) | def main(args, override_args=None):
  function cli_main (line 86) | def cli_main():

FILE: step11_final/blending_n_postprocessing.py
  function postprocess_single (line 52) | def postprocess_single(target, ref):
  function postprocess_prediction (line 79) | def postprocess_prediction(prediction, actual):

FILE: step1_lm_finetuning/callbacks.py
  class LosswiseSessionHandler (line 4) | class LosswiseSessionHandler:
    method __init__ (line 5) | def __init__(self, api_key, tag="", params=None):
    method create_graph (line 14) | def create_graph(
    method __getitem__ (line 28) | def __getitem__(self, graph_name):
    method done (line 33) | def done(self):
  class LosswiseCallback (line 37) | class LosswiseCallback(Callback):
    method __init__ (line 38) | def __init__(
    method on_train_begin (line 64) | def on_train_begin(self, logs):
    method on_train_end (line 77) | def on_train_end(self, logs):
    method on_epoch_end (line 81) | def on_epoch_end(self, epoch, logs):
    method on_batch_end (line 99) | def on_batch_end(self, batch, logs):
  class CSVParamLogger (line 121) | class CSVParamLogger(CSVLogger):
    method __init__ (line 122) | def __init__(
    method on_train_begin (line 139) | def on_train_begin(self, logs):

FILE: step1_lm_finetuning/data/augmentation/tokenization.py
  class BertRandomTokenizer (line 6) | class BertRandomTokenizer(BertTokenizer):
    method __init__ (line 7) | def __init__(
    method _split_word_piece (line 27) | def _split_word_piece(self, token: str) -> List[str]:
    method _tokenize (line 40) | def _tokenize(self, text):

FILE: step1_lm_finetuning/data/dataset.py
  class QuestDataset (line 82) | class QuestDataset(Dataset):
    method __init__ (line 83) | def __init__(
    method _encode_segments (line 124) | def _encode_segments(self, *text_segments: List[Text]) -> List[List[in...
    method _process (line 136) | def _process(self, title=None, body=None, answer=None):
    method _pad_and_truncate (line 150) | def _pad_and_truncate(self, features, pad_value=0):
    method _balance_segments (line 157) | def _balance_segments(
    method _prepare_features (line 174) | def _prepare_features(self, title, body, answer):
    method _get_text (line 214) | def _get_text(self, index):
    method __getitem__ (line 235) | def __getitem__(self, index):
    method __len__ (line 248) | def __len__(self):
  class TestQuestDataset (line 257) | class TestQuestDataset(QuestDataset):
    method __init__ (line 258) | def __init__(
    method __getitem__ (line 287) | def __getitem__(self, index):
  class QuestSiameseDataset (line 297) | class QuestSiameseDataset(QuestDataset):
    method __getitem__ (line 298) | def __getitem__(self, index):

FILE: step1_lm_finetuning/data/make_folds.py
  function rareness_split (line 12) | def rareness_split(train_df, least_representative_cols=("question_type_s...
  function aggregate_ordinals (line 27) | def aggregate_ordinals(group, agg_func=pd.Series.mode):
  function stratified_fold_split_for_common (line 36) | def stratified_fold_split_for_common(
  function stratified_fold_split_for_rare (line 82) | def stratified_fold_split_for_rare(

FILE: step1_lm_finetuning/data/sampler.py
  class UniformRandomSampler (line 5) | class UniformRandomSampler(Sampler):
    method __init__ (line 6) | def __init__(self, data_source, num_samples: int = None):
    method num_samples (line 12) | def num_samples(self):
    method __iter__ (line 17) | def __iter__(self):
    method __len__ (line 27) | def __len__(self):

FILE: step1_lm_finetuning/data_preparation/clean_stack_exchange_qa.py
  function merge_all_questions_and_answers (line 13) | def merge_all_questions_and_answers(path_to_parsed_dumps):
  function process (line 44) | def process(
  function select_answers (line 181) | def select_answers(all_answers, max_answers_per_question=2):

FILE: step1_lm_finetuning/data_preparation/scrape_stack_exchange.py
  function get_urls (line 12) | def get_urls(main_url, path_to_dump):
  function download_and_unzip_data (line 27) | def download_and_unzip_data(main_url, links, path_to_dump):
  function xml_to_pandas (line 39) | def xml_to_pandas(root, columns, row_name="row"):
  function parse_xml_dump (line 54) | def parse_xml_dump(pathes):
  function parse_dumps (line 131) | def parse_dumps(path_to_dump, out_dir):
  function main (line 144) | def main():

FILE: step1_lm_finetuning/train_stackx_lm.py
  class QuestMLMDataset (line 58) | class QuestMLMDataset(QuestDataset):
    method __init__ (line 59) | def __init__(
    method _mask_tokens (line 98) | def _mask_tokens(self, inputs, masked_random_replace_prob=0.2):
    method __getitem__ (line 132) | def __getitem__(self, index):
  class BertPretrain (line 179) | class BertPretrain(BertForPreTraining):
    method __init__ (line 180) | def __init__(self, config, num_labels):
    method forward (line 186) | def forward(
  function spearman_metric (line 268) | def spearman_metric(y_true, y_pred, return_scores=False, colnames=None):
  class Spearman (line 281) | class Spearman(EpochMetric):
    class SpearmanCallback (line 282) | class SpearmanCallback(Callback):
      method __init__ (line 283) | def __init__(self):
      method on_epoch_end (line 286) | def on_epoch_end(self, epoch, logs):
    method __init__ (line 289) | def __init__(self, colnames=None):
    method forward (line 297) | def forward(self, logits, targets):
    method get_metric (line 302) | def get_metric(self):
  class MaskLMCrossEntropyLoss (line 314) | class MaskLMCrossEntropyLoss(torch.nn.CrossEntropyLoss):
    method forward (line 315) | def forward(self, logits, targets):
  class SOPCrossEntropyLoss (line 323) | class SOPCrossEntropyLoss(torch.nn.CrossEntropyLoss):
    method forward (line 324) | def forward(self, logits, targets):
  class PretrainingLoss (line 331) | class PretrainingLoss(torch.nn.Module):
    method __init__ (line 332) | def __init__(self, targets_alpha=1.0):
    method forward (line 339) | def forward(self, logits, targets):
  class MaskLMPerplexity (line 347) | class MaskLMPerplexity(MaskLMCrossEntropyLoss):
    method forward (line 350) | def forward(self, logits, targets):
  function sop_accuracy (line 357) | def sop_accuracy(logits, targets):

FILE: step1_lm_finetuning/utils.py
  function encode_labels (line 11) | def encode_labels(df, target_columns=ALL_TARGETS, method="average"):
  function transform_target_columns_to_ordinals (line 22) | def transform_target_columns_to_ordinals(
  function torch_to_numpy (line 54) | def torch_to_numpy(obj, copy=False):
  function torch_to (line 92) | def torch_to(obj, *args, **kargs):
  function torch_apply (line 96) | def torch_apply(obj, func):
  function _apply (line 114) | def _apply(obj, func):
  function _concat (line 122) | def _concat(obj):
  function numpy_to_torch (line 133) | def numpy_to_torch(obj):

FILE: step2_pseudo_labeling/bert-base-pretrained/dataset.py
  function _get_masks (line 10) | def _get_masks(tokens, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, max_seq_length):
  function _get_ids (line 37) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 45) | def _trim_input(
  function _convert_to_bert_inputs (line 105) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function _get_stoken_output (line 117) | def _get_stoken_output(title, question, answer, tokenizer, max_sequence_...
  function compute_input_arays (line 124) | def compute_input_arays(
  function compute_output_arrays (line 165) | def compute_output_arrays(df, columns):
  class BucketingSampler (line 169) | class BucketingSampler:
    method __init__ (line 170) | def __init__(self, lengths, batch_size, maxlen=500):
    method _make_batches (line 178) | def _make_batches(self, lengths, batch_size, maxlen):
    method __len__ (line 206) | def __len__(self):
    method __iter__ (line 209) | def __iter__(self):
  function make_collate_fn (line 213) | def make_collate_fn(
  class QuestDataset (line 242) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 243) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 249) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 274) | def __len__(self):
    method __getitem__ (line 277) | def __getitem__(self, idx):
  function cross_validation_split (line 298) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 326) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 330) | def get_test_set(args, test_df, tokenizer):

FILE: step2_pseudo_labeling/bert-base-pretrained/evaluation.py
  function target_metric (line 8) | def target_metric(prediction, actual, columns=target_columns):

FILE: step2_pseudo_labeling/bert-base-pretrained/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 49) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 96) | def infer(args, model, test_loader, test_shape):

FILE: step2_pseudo_labeling/bert-base-pretrained/model.py
  class Squeeze (line 19) | class Squeeze(nn.Module):
    method __init__ (line 20) | def __init__(self, dim):
    method forward (line 24) | def forward(self, x):
  class CustomBert (line 28) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 29) | def __init__(self, config):
    method forward (line 46) | def forward(
  function get_model_optimizer (line 88) | def get_model_optimizer(args):

FILE: step2_pseudo_labeling/bert-base-pretrained/run.py
  function seed_everything (line 55) | def seed_everything(seed: int):

FILE: step2_pseudo_labeling/bert-base/dataset.py
  function _get_masks (line 10) | def _get_masks(tokens, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, max_seq_length):
  function _get_ids (line 37) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 45) | def _trim_input(
  function _convert_to_bert_inputs (line 105) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function _get_stoken_output (line 117) | def _get_stoken_output(title, question, answer, tokenizer, max_sequence_...
  function compute_input_arays (line 124) | def compute_input_arays(
  function compute_output_arrays (line 165) | def compute_output_arrays(df, columns):
  class BucketingSampler (line 169) | class BucketingSampler:
    method __init__ (line 170) | def __init__(self, lengths, batch_size, maxlen=500):
    method _make_batches (line 178) | def _make_batches(self, lengths, batch_size, maxlen):
    method __len__ (line 206) | def __len__(self):
    method __iter__ (line 209) | def __iter__(self):
  function make_collate_fn (line 213) | def make_collate_fn(
  class QuestDataset (line 242) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 243) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 249) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 274) | def __len__(self):
    method __getitem__ (line 277) | def __getitem__(self, idx):
  function cross_validation_split (line 298) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 326) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 330) | def get_test_set(args, test_df, tokenizer):

FILE: step2_pseudo_labeling/bert-base/evaluation.py
  function target_metric (line 8) | def target_metric(prediction, actual, columns=target_columns):

FILE: step2_pseudo_labeling/bert-base/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 49) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 96) | def infer(args, model, test_loader, test_shape):

FILE: step2_pseudo_labeling/bert-base/model.py
  class Squeeze (line 19) | class Squeeze(nn.Module):
    method __init__ (line 20) | def __init__(self, dim):
    method forward (line 24) | def forward(self, x):
  class CustomBert (line 28) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 29) | def __init__(self, config):
    method forward (line 46) | def forward(
  function get_model_optimizer (line 88) | def get_model_optimizer(args):

FILE: step2_pseudo_labeling/bert-base/run.py
  function seed_everything (line 55) | def seed_everything(seed: int):

FILE: step2_pseudo_labeling/bert-large/dataset.py
  function _get_masks (line 10) | def _get_masks(tokens, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, max_seq_length):
  function _get_ids (line 37) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 45) | def _trim_input(
  function _convert_to_bert_inputs (line 105) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function _get_stoken_output (line 117) | def _get_stoken_output(title, question, answer, tokenizer, max_sequence_...
  function compute_input_arays (line 124) | def compute_input_arays(
  function compute_output_arrays (line 165) | def compute_output_arrays(df, columns):
  class BucketingSampler (line 169) | class BucketingSampler:
    method __init__ (line 170) | def __init__(self, lengths, batch_size, maxlen=500):
    method _make_batches (line 178) | def _make_batches(self, lengths, batch_size, maxlen):
    method __len__ (line 206) | def __len__(self):
    method __iter__ (line 209) | def __iter__(self):
  function make_collate_fn (line 213) | def make_collate_fn(
  class QuestDataset (line 242) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 243) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 249) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 274) | def __len__(self):
    method __getitem__ (line 277) | def __getitem__(self, idx):
  function cross_validation_split (line 298) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 326) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 330) | def get_test_set(args, test_df, tokenizer):

FILE: step2_pseudo_labeling/bert-large/evaluation.py
  function target_metric (line 8) | def target_metric(prediction, actual, columns=target_columns):

FILE: step2_pseudo_labeling/bert-large/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 49) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 96) | def infer(args, model, test_loader, test_shape):

FILE: step2_pseudo_labeling/bert-large/model.py
  class Squeeze (line 19) | class Squeeze(nn.Module):
    method __init__ (line 20) | def __init__(self, dim):
    method forward (line 24) | def forward(self, x):
  class CustomBert (line 28) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 29) | def __init__(self, config):
    method forward (line 46) | def forward(
  function get_model_optimizer (line 88) | def get_model_optimizer(args):

FILE: step2_pseudo_labeling/bert-large/run.py
  function seed_everything (line 55) | def seed_everything(seed: int):

FILE: step3_model1_bert_code/bert.py
  function gelu (line 71) | def gelu(x):
  function swish (line 80) | def swish(x):
  class BertConfig (line 87) | class BertConfig(PretrainedConfig):
    method __init__ (line 118) | def __init__(
  class BertEmbeddings (line 172) | class BertEmbeddings(nn.Module):
    method __init__ (line 176) | def __init__(self, config):
    method forward (line 193) | def forward(self, input_ids, token_type_ids=None, position_ids=None):
  class BertSelfAttention (line 213) | class BertSelfAttention(nn.Module):
    method __init__ (line 214) | def __init__(self, config):
    method transpose_for_scores (line 233) | def transpose_for_scores(self, x):
    method forward (line 241) | def forward(self, hidden_states, attention_mask, head_mask=None):
  class BertSelfOutput (line 281) | class BertSelfOutput(nn.Module):
    method __init__ (line 282) | def __init__(self, config):
    method forward (line 288) | def forward(self, hidden_states, input_tensor):
  class BertAttention (line 295) | class BertAttention(nn.Module):
    method __init__ (line 296) | def __init__(self, config):
    method prune_heads (line 302) | def prune_heads(self, heads):
    method forward (line 329) | def forward(self, input_tensor, attention_mask, head_mask=None):
  class BertIntermediate (line 338) | class BertIntermediate(nn.Module):
    method __init__ (line 339) | def __init__(self, config):
    method forward (line 349) | def forward(self, hidden_states):
  class BertOutput (line 355) | class BertOutput(nn.Module):
    method __init__ (line 356) | def __init__(self, config):
    method forward (line 362) | def forward(self, hidden_states, input_tensor):
  class BertLayer (line 369) | class BertLayer(nn.Module):
    method __init__ (line 370) | def __init__(self, config):
    method forward (line 376) | def forward(self, hidden_states, attention_mask, head_mask=None):
  class BertEncoder (line 387) | class BertEncoder(nn.Module):
    method __init__ (line 388) | def __init__(self, config):
    method forward (line 396) | def forward(self, hidden_states, attention_mask, head_mask=None):
  class BertPooler (line 421) | class BertPooler(nn.Module):
    method __init__ (line 422) | def __init__(self, config):
    method forward (line 427) | def forward(self, hidden_states):
  class BertPredictionHeadTransform (line 436) | class BertPredictionHeadTransform(nn.Module):
    method __init__ (line 437) | def __init__(self, config):
    method forward (line 448) | def forward(self, hidden_states):
  class BertLMPredictionHead (line 455) | class BertLMPredictionHead(nn.Module):
    method __init__ (line 456) | def __init__(self, config):
    method forward (line 466) | def forward(self, hidden_states):
  class BertOnlyMLMHead (line 472) | class BertOnlyMLMHead(nn.Module):
    method __init__ (line 473) | def __init__(self, config):
    method forward (line 477) | def forward(self, sequence_output):
  class BertOnlyNSPHead (line 482) | class BertOnlyNSPHead(nn.Module):
    method __init__ (line 483) | def __init__(self, config):
    method forward (line 487) | def forward(self, pooled_output):
  class BertPreTrainingHeads (line 492) | class BertPreTrainingHeads(nn.Module):
    method __init__ (line 493) | def __init__(self, config):
    method forward (line 498) | def forward(self, sequence_output, pooled_output):
  class BertPreTrainedModel (line 504) | class BertPreTrainedModel(PreTrainedModel):
    method _init_weights (line 514) | def _init_weights(self, module):
  class BertModel (line 596) | class BertModel(BertPreTrainedModel):
    method __init__ (line 626) | def __init__(self, config):
    method _resize_token_embeddings (line 635) | def _resize_token_embeddings(self, new_num_tokens):
    method _prune_heads (line 641) | def _prune_heads(self, heads_to_prune):
    method forward (line 649) | def forward(
  class BertForPreTraining (line 723) | class BertForPreTraining(BertPreTrainedModel):
    method __init__ (line 761) | def __init__(self, config):
    method tie_weights (line 770) | def tie_weights(self):
    method forward (line 778) | def forward(
  class BertForMaskedLM (line 825) | class BertForMaskedLM(BertPreTrainedModel):
    method __init__ (line 856) | def __init__(self, config):
    method tie_weights (line 865) | def tie_weights(self):
    method forward (line 873) | def forward(
  class BertForNextSentencePrediction (line 912) | class BertForNextSentencePrediction(BertPreTrainedModel):
    method __init__ (line 943) | def __init__(self, config):
    method forward (line 951) | def forward(
  class BertForSequenceClassification (line 990) | class BertForSequenceClassification(BertPreTrainedModel):
    method __init__ (line 1022) | def __init__(self, config):
    method forward (line 1032) | def forward(
  class BertForMultipleChoice (line 1075) | class BertForMultipleChoice(BertPreTrainedModel):
    method __init__ (line 1144) | def __init__(self, config):
    method forward (line 1153) | def forward(
  class BertForTokenClassification (line 1211) | class BertForTokenClassification(BertPreTrainedModel):
    method __init__ (line 1241) | def __init__(self, config):
    method forward (line 1251) | def forward(
  class BertForQuestionAnswering (line 1296) | class BertForQuestionAnswering(BertPreTrainedModel):
    method __init__ (line 1334) | def __init__(self, config):
    method forward (line 1343) | def forward(

FILE: step3_model1_bert_code/callbacks.py
  class LosswiseSessionHandler (line 4) | class LosswiseSessionHandler:
    method __init__ (line 5) | def __init__(self, api_key, tag="", params=None):
    method create_graph (line 14) | def create_graph(
    method __getitem__ (line 28) | def __getitem__(self, graph_name):
    method done (line 33) | def done(self):
  class LosswiseCallback (line 37) | class LosswiseCallback(Callback):
    method __init__ (line 38) | def __init__(
    method on_train_begin (line 64) | def on_train_begin(self, logs):
    method on_train_end (line 77) | def on_train_end(self, logs):
    method on_epoch_end (line 81) | def on_epoch_end(self, epoch, logs):
    method on_batch_end (line 99) | def on_batch_end(self, batch, logs):
  class CSVParamLogger (line 121) | class CSVParamLogger(CSVLogger):
    method __init__ (line 122) | def __init__(
    method on_train_begin (line 139) | def on_train_begin(self, logs):

FILE: step3_model1_bert_code/data/augmentation/tokenization.py
  class BertRandomTokenizer (line 6) | class BertRandomTokenizer(BertTokenizer):
    method __init__ (line 7) | def __init__(
    method _split_word_piece (line 27) | def _split_word_piece(self, token: str) -> List[str]:
    method _tokenize (line 40) | def _tokenize(self, text):

FILE: step3_model1_bert_code/data/dataset.py
  class QuestDataset (line 82) | class QuestDataset(Dataset):
    method __init__ (line 83) | def __init__(
    method _encode_segments (line 124) | def _encode_segments(self, *text_segments: List[Text]) -> List[List[in...
    method _process (line 136) | def _process(self, title=None, body=None, answer=None):
    method _pad_and_truncate (line 150) | def _pad_and_truncate(self, features, pad_value=0):
    method _balance_segments (line 157) | def _balance_segments(
    method _prepare_features (line 174) | def _prepare_features(self, title, body, answer):
    method _get_text (line 214) | def _get_text(self, index):
    method __getitem__ (line 235) | def __getitem__(self, index):
    method __len__ (line 248) | def __len__(self):
  class TestQuestDataset (line 257) | class TestQuestDataset(QuestDataset):
    method __init__ (line 258) | def __init__(
    method __getitem__ (line 287) | def __getitem__(self, index):
  class QuestSiameseDataset (line 297) | class QuestSiameseDataset(QuestDataset):
    method __getitem__ (line 298) | def __getitem__(self, index):

FILE: step3_model1_bert_code/data/make_folds.py
  function rareness_split (line 12) | def rareness_split(train_df, least_representative_cols=("question_type_s...
  function aggregate_ordinals (line 27) | def aggregate_ordinals(group, agg_func=pd.Series.mode):
  function stratified_fold_split_for_common (line 36) | def stratified_fold_split_for_common(
  function stratified_fold_split_for_rare (line 82) | def stratified_fold_split_for_rare(

FILE: step3_model1_bert_code/data/sampler.py
  class UniformRandomSampler (line 5) | class UniformRandomSampler(Sampler):
    method __init__ (line 6) | def __init__(self, data_source, num_samples: int = None):
    method num_samples (line 12) | def num_samples(self):
    method __iter__ (line 17) | def __iter__(self):
    method __len__ (line 27) | def __len__(self):

FILE: step3_model1_bert_code/metrics.py
  function spearman_metric (line 9) | def spearman_metric(y_true, y_pred, return_scores=False, colnames=None):
  class Spearman (line 22) | class Spearman(EpochMetric):
    class SpearmanCallback (line 23) | class SpearmanCallback(Callback):
      method __init__ (line 24) | def __init__(self):
      method on_epoch_end (line 27) | def on_epoch_end(self, epoch, logs):
    method __init__ (line 30) | def __init__(self, colnames=None):
    method forward (line 38) | def forward(self, y_pred, y_true):
    method get_metric (line 42) | def get_metric(self):

FILE: step3_model1_bert_code/models.py
  class BertForQuestRegression (line 8) | class BertForQuestRegression(BertPreTrainedModel):
    method __init__ (line 9) | def __init__(self, config, head_dropout=None):
    method forward (line 22) | def forward(
    method load (line 45) | def load(self, checkpoint, strict=True, **cfg_args):
  class RobertaForQuestRegression (line 53) | class RobertaForQuestRegression(BertPreTrainedModel):
    method __init__ (line 54) | def __init__(self, config):
    method forward (line 63) | def forward(
    method load (line 86) | def load(self, checkpoint, strict=True, **cfg_args):
  class CustomBert (line 94) | class CustomBert(transformers.BertPreTrainedModel):
    method __init__ (line 95) | def __init__(self, config):
    method forward (line 112) | def forward(
  function get_optimizer (line 147) | def get_optimizer(model, learning_rate, backbone_prefix="bert"):

FILE: step3_model1_bert_code/schedule.py
  class _PyTorchLRSchedulerWrapper (line 6) | class _PyTorchLRSchedulerWrapper(Callback):
    method __init__ (line 7) | def __init__(self, torch_lr_scheduler, *args, **kwargs):
    method on_train_begin (line 15) | def on_train_begin(self, logs):
    method on_batch_end (line 25) | def on_batch_end(self, batch, logs):
    method load_state (line 28) | def load_state(self, f):
    method save_state (line 34) | def save_state(self, f):
  class _TotalStepWrapper (line 38) | class _TotalStepWrapper(_PyTorchLRSchedulerWrapper):
    method on_train_begin (line 39) | def on_train_begin(self, logs):
  class ConstantLRSchedule (line 60) | class ConstantLRSchedule(_PyTorchLRSchedulerWrapper):
    method __init__ (line 64) | def __init__(self, last_epoch=-1):
  class WarmupConstantSchedule (line 68) | class WarmupConstantSchedule(_PyTorchLRSchedulerWrapper):
    method __init__ (line 74) | def __init__(self, warmup_steps, last_epoch=-1):
  class WarmupLinearSchedule (line 80) | class WarmupLinearSchedule(_TotalStepWrapper):
    method __init__ (line 86) | def __init__(self, warmup_steps, t_total=None, last_epoch=-1):
  class WarmupCosineSchedule (line 95) | class WarmupCosineSchedule(_TotalStepWrapper):
    method __init__ (line 102) | def __init__(self, warmup_steps, t_total=None, cycles=0.5, last_epoch=...
  class WarmupCosineWithHardRestartsSchedule (line 112) | class WarmupCosineWithHardRestartsSchedule(_TotalStepWrapper):
    method __init__ (line 119) | def __init__(self, warmup_steps, t_total=None, cycles=1.0, last_epoch=...

FILE: step3_model1_bert_code/train.py
  function get_model (line 33) | def get_model():

FILE: step3_model1_bert_code/utils.py
  function encode_labels (line 10) | def encode_labels(df, target_columns=ALL_TARGETS, method="average"):
  function transform_target_columns_to_ordinals (line 21) | def transform_target_columns_to_ordinals(
  function torch_to_numpy (line 53) | def torch_to_numpy(obj, copy=False):
  function torch_to (line 91) | def torch_to(obj, *args, **kargs):
  function torch_apply (line 95) | def torch_apply(obj, func):
  function _apply (line 113) | def _apply(obj, func):
  function _concat (line 121) | def _concat(obj):
  function numpy_to_torch (line 132) | def numpy_to_torch(obj):

FILE: step4_model2_bert_code/dataset.py
  function _get_masks (line 12) | def _get_masks(tokens, max_seq_length):
  function _get_segments (line 19) | def _get_segments(tokens, max_seq_length):
  function _get_ids (line 39) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 47) | def _trim_input(
  function _convert_to_bert_inputs (line 107) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function _get_stoken_output (line 119) | def _get_stoken_output(title, question, answer, tokenizer, max_sequence_...
  function compute_input_arays (line 126) | def compute_input_arays(
  function compute_output_arrays (line 167) | def compute_output_arrays(df, columns):
  class BucketingSampler (line 171) | class BucketingSampler:
    method __init__ (line 172) | def __init__(self, lengths, batch_size, maxlen=500):
    method _make_batches (line 180) | def _make_batches(self, lengths, batch_size, maxlen):
    method __len__ (line 208) | def __len__(self):
    method __iter__ (line 211) | def __iter__(self):
  function make_collate_fn (line 215) | def make_collate_fn(
  class QuestDataset (line 244) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 245) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 251) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 276) | def __len__(self):
    method __getitem__ (line 279) | def __getitem__(self, idx):
  function cross_validation_split (line 300) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 328) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 332) | def get_test_set(args, test_df, tokenizer):

FILE: step4_model2_bert_code/evaluation.py
  function target_metric (line 8) | def target_metric(prediction, actual, columns=target_columns):

FILE: step4_model2_bert_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 49) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 96) | def infer(args, model, test_loader, test_shape):

FILE: step4_model2_bert_code/model.py
  class Squeeze (line 19) | class Squeeze(nn.Module):
    method __init__ (line 20) | def __init__(self, dim):
    method forward (line 24) | def forward(self, x):
  class CustomBert (line 28) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 29) | def __init__(self, config):
    method forward (line 46) | def forward(
  function get_model_optimizer (line 88) | def get_model_optimizer(args):

FILE: step4_model2_bert_code/run.py
  function seed_everything (line 55) | def seed_everything(seed: int):

FILE: step5_model3_roberta_code/augmentation.py
  class BertRandomTokenizer (line 6) | class BertRandomTokenizer(BertTokenizer):
    method __init__ (line 7) | def __init__(
    method _split_word_piece (line 27) | def _split_word_piece(self, token: str) -> List[str]:
    method _tokenize (line 40) | def _tokenize(self, text):

FILE: step5_model3_roberta_code/dataset.py
  function _get_masks (line 9) | def _get_masks(tokens, tokenizer, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, tokenizer, max_seq_length):
  function _get_ids (line 38) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 47) | def _trim_input(
  function _convert_to_bert_inputs (line 107) | def _convert_to_bert_inputs(
  function compute_input_arrays (line 140) | def compute_input_arrays(
  function compute_output_arrays (line 189) | def compute_output_arrays(df, columns):
  class QuestDataset (line 193) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 194) | def __init__(
    method from_frame (line 214) | def from_frame(
    method __getitem__ (line 234) | def __getitem__(self, idx):
    method __len__ (line 270) | def __len__(self):
  function cross_validation_split (line 274) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 302) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 306) | def get_test_set(args, test_df, tokenizer):

FILE: step5_model3_roberta_code/evaluation.py
  function target_metric (line 6) | def target_metric(prediction, actual):

FILE: step5_model3_roberta_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 44) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 84) | def infer(args, model, test_loader, test_shape):

FILE: step5_model3_roberta_code/model.py
  class Squeeze (line 10) | class Squeeze(nn.Module):
    method __init__ (line 11) | def __init__(self, dim):
    method forward (line 15) | def forward(self, x):
  class CustomBert (line 19) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 20) | def __init__(self, config):
    method forward (line 37) | def forward(
  class CustomRoberta (line 75) | class CustomRoberta(BertPreTrainedModel):
    method __init__ (line 76) | def __init__(self, config):
    method forward (line 93) | def forward(
  function get_model_optimizer (line 132) | def get_model_optimizer(args):

FILE: step5_model3_roberta_code/run.py
  function seed_everything (line 47) | def seed_everything(seed: int):

FILE: step6_model4_bart_code/dataset.py
  function _get_ids (line 16) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 23) | def _trim_input(
  function _convert_to_bert_inputs (line 83) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function compute_input_arays (line 93) | def compute_input_arays(
  function compute_output_arrays (line 134) | def compute_output_arrays(df, columns):
  class QuestDataset (line 138) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 139) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 145) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 169) | def __len__(self):
    method __getitem__ (line 172) | def __getitem__(self, idx):
  function cross_validation_split (line 183) | def cross_validation_split(
  function get_pseudo_set (line 233) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 237) | def get_test_set(args, test_df, tokenizer):

FILE: step6_model4_bart_code/evaluation.py
  function target_metric (line 8) | def target_metric(prediction, actual):

FILE: step6_model4_bart_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 35) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 69) | def infer(args, model, test_loader, test_shape):

FILE: step6_model4_bart_code/model.py
  class Squeeze (line 22) | class Squeeze(nn.Module):
    method __init__ (line 23) | def __init__(self, dim):
    method forward (line 27) | def forward(self, x):
  class CustomBART (line 31) | class CustomBART(nn.Module):
    method __init__ (line 32) | def __init__(self, model_name, num_labels, num_hidden_layers=12, hidde...
    method forward (line 45) | def forward(self, input_ids=None):
  class BARTTokenizer (line 69) | class BARTTokenizer:
    method hub_models (line 71) | def hub_models(cls):
    method __init__ (line 78) | def __init__(self, args, task):
    method encode (line 85) | def encode(
    method from_pretrained (line 114) | def from_pretrained(
  function get_model_optimizer (line 136) | def get_model_optimizer(args):

FILE: step6_model4_bart_code/run.py
  function seed_everything (line 49) | def seed_everything(seed: int):

FILE: steps7_10_inference/model1_bert_code/callbacks.py
  class LosswiseSessionHandler (line 4) | class LosswiseSessionHandler:
    method __init__ (line 5) | def __init__(self, api_key, tag="", params=None):
    method create_graph (line 14) | def create_graph(
    method __getitem__ (line 28) | def __getitem__(self, graph_name):
    method done (line 33) | def done(self):
  class LosswiseCallback (line 37) | class LosswiseCallback(Callback):
    method __init__ (line 38) | def __init__(
    method on_train_begin (line 64) | def on_train_begin(self, logs):
    method on_train_end (line 77) | def on_train_end(self, logs):
    method on_epoch_end (line 81) | def on_epoch_end(self, epoch, logs):
    method on_batch_end (line 99) | def on_batch_end(self, batch, logs):
  class CSVParamLogger (line 121) | class CSVParamLogger(CSVLogger):
    method __init__ (line 122) | def __init__(
    method on_train_begin (line 139) | def on_train_begin(self, logs):

FILE: steps7_10_inference/model1_bert_code/data/augmentation/tokenization.py
  class BertRandomTokenizer (line 6) | class BertRandomTokenizer(BertTokenizer):
    method __init__ (line 7) | def __init__(
    method _split_word_piece (line 27) | def _split_word_piece(self, token: str) -> List[str]:
    method _tokenize (line 40) | def _tokenize(self, text):

FILE: steps7_10_inference/model1_bert_code/data/dataset.py
  class QuestDataset (line 82) | class QuestDataset(Dataset):
    method __init__ (line 83) | def __init__(
    method _encode_segments (line 124) | def _encode_segments(self, *text_segments: List[Text]) -> List[List[in...
    method _process (line 136) | def _process(self, title=None, body=None, answer=None):
    method _pad_and_truncate (line 150) | def _pad_and_truncate(self, features, pad_value=0):
    method _balance_segments (line 157) | def _balance_segments(
    method _prepare_features (line 174) | def _prepare_features(self, title, body, answer):
    method _get_text (line 214) | def _get_text(self, index):
    method __getitem__ (line 235) | def __getitem__(self, index):
    method __len__ (line 248) | def __len__(self):
  class TestQuestDataset (line 257) | class TestQuestDataset(QuestDataset):
    method __init__ (line 258) | def __init__(
    method __getitem__ (line 287) | def __getitem__(self, index):
  class QuestSiameseDataset (line 297) | class QuestSiameseDataset(QuestDataset):
    method __getitem__ (line 298) | def __getitem__(self, index):

FILE: steps7_10_inference/model1_bert_code/data/make_folds.py
  function rareness_split (line 12) | def rareness_split(train_df, least_representative_cols=("question_type_s...
  function aggregate_ordinals (line 27) | def aggregate_ordinals(group, agg_func=pd.Series.mode):
  function stratified_fold_split_for_common (line 36) | def stratified_fold_split_for_common(
  function stratified_fold_split_for_rare (line 82) | def stratified_fold_split_for_rare(

FILE: steps7_10_inference/model1_bert_code/data/sampler.py
  class UniformRandomSampler (line 5) | class UniformRandomSampler(Sampler):
    method __init__ (line 6) | def __init__(self, data_source, num_samples: int = None):
    method num_samples (line 12) | def num_samples(self):
    method __iter__ (line 17) | def __iter__(self):
    method __len__ (line 27) | def __len__(self):

FILE: steps7_10_inference/model1_bert_code/metrics.py
  function spearman_metric (line 9) | def spearman_metric(y_true, y_pred, return_scores=False, colnames=None):
  class Spearman (line 22) | class Spearman(EpochMetric):
    class SpearmanCallback (line 23) | class SpearmanCallback(Callback):
      method __init__ (line 24) | def __init__(self):
      method on_epoch_end (line 27) | def on_epoch_end(self, epoch, logs):
    method __init__ (line 30) | def __init__(self, colnames=None):
    method forward (line 38) | def forward(self, y_pred, y_true):
    method get_metric (line 42) | def get_metric(self):

FILE: steps7_10_inference/model1_bert_code/models.py
  class BertForQuestRegression (line 9) | class BertForQuestRegression(BertPreTrainedModel):
    method __init__ (line 10) | def __init__(self, config, head_dropout=None):
    method forward (line 23) | def forward(
    method load (line 46) | def load(self, checkpoint, strict=True, **cfg_args):
  class RobertaForQuestRegression (line 54) | class RobertaForQuestRegression(BertPreTrainedModel):
    method __init__ (line 55) | def __init__(self, config):
    method forward (line 64) | def forward(
    method load (line 87) | def load(self, checkpoint, strict=True, **cfg_args):
  class CustomBert (line 95) | class CustomBert(transformers.BertPreTrainedModel):
    method __init__ (line 96) | def __init__(self, config):
    method forward (line 113) | def forward(
  function get_optimizer (line 148) | def get_optimizer(model, learning_rate, backbone_prefix="bert"):

FILE: steps7_10_inference/model1_bert_code/predict_test.py
  class BertForQuestRegression (line 13) | class BertForQuestRegression(BertPreTrainedModel):
    method __init__ (line 14) | def __init__(self, config, head_dropout=None):
    method forward (line 27) | def forward(
    method load (line 50) | def load(self, checkpoint, strict=True, **cfg_args):
  class QuestDataset (line 95) | class QuestDataset(Dataset):
    method __init__ (line 96) | def __init__(
    method _encode_segments (line 137) | def _encode_segments(self, *text_segments: List[Text]) -> List[List[in...
    method _process (line 149) | def _process(self, title=None, body=None, answer=None):
    method _pad_and_truncate (line 163) | def _pad_and_truncate(self, features, pad_value=0):
    method _balance_segments (line 170) | def _balance_segments(
    method _prepare_features (line 187) | def _prepare_features(self, title, body, answer):
    method _get_text (line 227) | def _get_text(self, index):
    method __getitem__ (line 248) | def __getitem__(self, index):
    method __len__ (line 261) | def __len__(self):
  class TestQuestDataset (line 270) | class TestQuestDataset(QuestDataset):
    method __init__ (line 271) | def __init__(
    method __getitem__ (line 300) | def __getitem__(self, index):
  function predict (line 310) | def predict(model, test_loader, columns, device="cuda"):
  function torch_to_numpy (line 328) | def torch_to_numpy(obj, copy=False):
  function torch_to (line 336) | def torch_to(obj, *args, **kargs):
  function torch_apply (line 340) | def torch_apply(obj, func):
  function _apply (line 345) | def _apply(obj, func):
  function get_model (line 366) | def get_model(targets=ALL_TARGETS):
  function predict_test_checkpoints (line 375) | def predict_test_checkpoints(checkpoints, test_loader, targets, device="...

FILE: steps7_10_inference/model1_bert_code/schedule.py
  class _PyTorchLRSchedulerWrapper (line 6) | class _PyTorchLRSchedulerWrapper(Callback):
    method __init__ (line 7) | def __init__(self, torch_lr_scheduler, *args, **kwargs):
    method on_train_begin (line 15) | def on_train_begin(self, logs):
    method on_batch_end (line 25) | def on_batch_end(self, batch, logs):
    method load_state (line 28) | def load_state(self, f):
    method save_state (line 34) | def save_state(self, f):
  class _TotalStepWrapper (line 38) | class _TotalStepWrapper(_PyTorchLRSchedulerWrapper):
    method on_train_begin (line 39) | def on_train_begin(self, logs):
  class ConstantLRSchedule (line 60) | class ConstantLRSchedule(_PyTorchLRSchedulerWrapper):
    method __init__ (line 64) | def __init__(self, last_epoch=-1):
  class WarmupConstantSchedule (line 68) | class WarmupConstantSchedule(_PyTorchLRSchedulerWrapper):
    method __init__ (line 74) | def __init__(self, warmup_steps, last_epoch=-1):
  class WarmupLinearSchedule (line 80) | class WarmupLinearSchedule(_TotalStepWrapper):
    method __init__ (line 86) | def __init__(self, warmup_steps, t_total=None, last_epoch=-1):
  class WarmupCosineSchedule (line 95) | class WarmupCosineSchedule(_TotalStepWrapper):
    method __init__ (line 102) | def __init__(self, warmup_steps, t_total=None, cycles=0.5, last_epoch=...
  class WarmupCosineWithHardRestartsSchedule (line 112) | class WarmupCosineWithHardRestartsSchedule(_TotalStepWrapper):
    method __init__ (line 119) | def __init__(self, warmup_steps, t_total=None, cycles=1.0, last_epoch=...

FILE: steps7_10_inference/model1_bert_code/utils.py
  function encode_labels (line 11) | def encode_labels(df, target_columns=ALL_TARGETS, method="average"):
  function transform_target_columns_to_ordinals (line 22) | def transform_target_columns_to_ordinals(
  function torch_to_numpy (line 54) | def torch_to_numpy(obj, copy=False):
  function torch_to (line 92) | def torch_to(obj, *args, **kargs):
  function torch_apply (line 96) | def torch_apply(obj, func):
  function _apply (line 114) | def _apply(obj, func):
  function _concat (line 122) | def _concat(obj):
  function numpy_to_torch (line 133) | def numpy_to_torch(obj):

FILE: steps7_10_inference/model2_bert_code/dataset.py
  function _get_masks (line 10) | def _get_masks(tokens, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, max_seq_length):
  function _get_ids (line 37) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 45) | def _trim_input(
  function _convert_to_bert_inputs (line 105) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function _get_stoken_output (line 117) | def _get_stoken_output(title, question, answer, tokenizer, max_sequence_...
  function compute_input_arays (line 124) | def compute_input_arays(
  function compute_output_arrays (line 169) | def compute_output_arrays(df, columns):
  class QuestDataset (line 173) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 174) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 180) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 204) | def __len__(self):
    method __getitem__ (line 207) | def __getitem__(self, idx):
  function cross_validation_split (line 220) | def cross_validation_split(
  function get_test_set (line 270) | def get_test_set(args, test_df, tokenizer):

FILE: steps7_10_inference/model2_bert_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 44) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 84) | def infer(args, model, test_loader, test_shape):

FILE: steps7_10_inference/model2_bert_code/model.py
  class Squeeze (line 10) | class Squeeze(nn.Module):
    method __init__ (line 11) | def __init__(self, dim):
    method forward (line 15) | def forward(self, x):
  class CustomBert (line 19) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 20) | def __init__(self, config):
    method forward (line 37) | def forward(
  function get_model_optimizer (line 78) | def get_model_optimizer(args):

FILE: steps7_10_inference/model3_roberta_code/augmentation.py
  class BertRandomTokenizer (line 6) | class BertRandomTokenizer(BertTokenizer):
    method __init__ (line 7) | def __init__(
    method _split_word_piece (line 27) | def _split_word_piece(self, token: str) -> List[str]:
    method _tokenize (line 40) | def _tokenize(self, text):

FILE: steps7_10_inference/model3_roberta_code/dataset.py
  function _get_masks (line 9) | def _get_masks(tokens, tokenizer, max_seq_length):
  function _get_segments (line 17) | def _get_segments(tokens, tokenizer, max_seq_length):
  function _get_ids (line 38) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 47) | def _trim_input(
  function _convert_to_bert_inputs (line 107) | def _convert_to_bert_inputs(
  function compute_input_arrays (line 140) | def compute_input_arrays(
  function compute_output_arrays (line 189) | def compute_output_arrays(df, columns):
  class QuestDataset (line 193) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 194) | def __init__(
    method from_frame (line 214) | def from_frame(
    method __getitem__ (line 234) | def __getitem__(self, idx):
    method __len__ (line 270) | def __len__(self):
  function cross_validation_split (line 274) | def cross_validation_split(args, train_df, tokenizer, ignore_train=False):
  function get_pseudo_set (line 302) | def get_pseudo_set(args, pseudo_df, tokenizer):
  function get_test_set (line 306) | def get_test_set(args, test_df, tokenizer):

FILE: steps7_10_inference/model3_roberta_code/evaluation.py
  function target_metric (line 6) | def target_metric(prediction, actual):

FILE: steps7_10_inference/model3_roberta_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 44) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 84) | def infer(args, model, test_loader, test_shape):

FILE: steps7_10_inference/model3_roberta_code/model.py
  class Squeeze (line 10) | class Squeeze(nn.Module):
    method __init__ (line 11) | def __init__(self, dim):
    method forward (line 15) | def forward(self, x):
  class CustomBert (line 19) | class CustomBert(BertPreTrainedModel):
    method __init__ (line 20) | def __init__(self, config):
    method forward (line 37) | def forward(
  class CustomRoberta (line 75) | class CustomRoberta(BertPreTrainedModel):
    method __init__ (line 76) | def __init__(self, config):
    method forward (line 93) | def forward(
  function get_model_optimizer (line 132) | def get_model_optimizer(args):

FILE: steps7_10_inference/model3_roberta_code/run.py
  function seed_everything (line 47) | def seed_everything(seed: int):

FILE: steps7_10_inference/model4_bart_code/dataset.py
  function _get_ids (line 16) | def _get_ids(tokens, tokenizer, max_seq_length):
  function _trim_input (line 23) | def _trim_input(
  function _convert_to_bert_inputs (line 83) | def _convert_to_bert_inputs(title, question, answer, tokenizer, max_sequ...
  function compute_input_arays (line 93) | def compute_input_arays(
  function compute_output_arrays (line 134) | def compute_output_arrays(df, columns):
  class QuestDataset (line 138) | class QuestDataset(torch.utils.data.Dataset):
    method __init__ (line 139) | def __init__(self, inputs, lengths, labels=None):
    method from_frame (line 145) | def from_frame(cls, args, df, tokenizer, test=False):
    method __len__ (line 169) | def __len__(self):
    method __getitem__ (line 172) | def __getitem__(self, idx):
  function cross_validation_split (line 183) | def cross_validation_split(
  function get_test_set (line 233) | def get_test_set(args, test_df, tokenizer):

FILE: steps7_10_inference/model4_bart_code/loops.py
  function train_loop (line 8) | def train_loop(model, train_loader, optimizer, criterion, scheduler, arg...
  function evaluate (line 35) | def evaluate(args, model, val_loader, criterion, val_shape):
  function infer (line 69) | def infer(args, model, test_loader, test_shape):

FILE: steps7_10_inference/model4_bart_code/model.py
  class CustomBART (line 10) | class CustomBART(nn.Module):
    method __init__ (line 11) | def __init__(self, model_name, num_labels, num_hidden_layers=12, hidde...
    method forward (line 24) | def forward(self, input_ids=None):
  function get_model (line 48) | def get_model(args):