SYMBOL INDEX (778 symbols across 48 files)

FILE: CPM-Generate/arguments.py
  function add_model_config_args (line 23) | def add_model_config_args(parser):
  function add_fp16_config_args (line 70) | def add_fp16_config_args(parser):
  function add_training_args (line 99) | def add_training_args(parser):
  function add_evaluation_args (line 177) | def add_evaluation_args(parser):
  function add_text_generate_args (line 210) | def add_text_generate_args(parser):
  function add_data_args (line 221) | def add_data_args(parser):
  function get_args (line 311) | def get_args():

FILE: CPM-Generate/configure_data.py
  class DataConfig (line 24) | class DataConfig:
    method __init__ (line 26) | def __init__(self, defaults={}):
    method apply (line 30) | def apply(self, args):
    method set_defaults (line 36) | def set_defaults(self, **kwargs):
    method apply_defaults (line 40) | def apply_defaults(self, args):
  function make_data_loader (line 47) | def make_data_loader(dataset, batch_size, args):
  function make_tfrecord_loaders (line 79) | def make_tfrecord_loaders(args):
  function make_loaders (line 116) | def make_loaders(args):
  function get_split (line 204) | def get_split(args):
  function configure_data (line 228) | def configure_data():

FILE: CPM-Generate/data/bert_dataset.py
  function build_train_valid_test_datasets (line 32) | def build_train_valid_test_datasets(data_prefix, data_impl, splits_string,
  class BertDataset (line 102) | class BertDataset(Dataset):
    method __init__ (line 104) | def __init__(self, name, indexed_dataset, data_prefix,
    method __len__ (line 136) | def __len__(self):
    method __getitem__ (line 139) | def __getitem__(self, idx):
  function get_indexed_dataset_ (line 157) | def get_indexed_dataset_(data_prefix, data_impl, skip_warmup):
  function get_train_valid_test_split_ (line 178) | def get_train_valid_test_split_(splits_string, size):
  function get_samples_mapping_ (line 206) | def get_samples_mapping_(indexed_dataset,

FILE: CPM-Generate/data/dataset_utils.py
  function compile_helper (line 25) | def compile_helper():
  function build_training_sample (line 38) | def build_training_sample(sample,
  function get_a_and_b_segments (line 100) | def get_a_and_b_segments(sample, np_rng):
  function truncate_segments (line 132) | def truncate_segments(tokens_a, tokens_b, len_a, len_b, max_num_tokens, ...
  function create_tokens_and_tokentypes (line 153) | def create_tokens_and_tokentypes(tokens_a, tokens_b, cls_id, sep_id):
  function is_start_piece (line 183) | def is_start_piece(piece):
  function create_masked_lm_predictions (line 192) | def create_masked_lm_predictions(tokens,
  function pad_and_convert_to_numpy (line 376) | def pad_and_convert_to_numpy(tokens, tokentypes, masked_positions,

FILE: CPM-Generate/data/gpt2_dataset.py
  function build_train_valid_test_datasets (line 30) | def build_train_valid_test_datasets(data_prefix, data_impl, splits_string,
  function get_indexed_dataset_ (line 73) | def get_indexed_dataset_(data_prefix, data_impl, skip_warmup):
  class GPT2Dataset (line 89) | class GPT2Dataset(torch.utils.data.Dataset):
    method __init__ (line 91) | def __init__(self, name, data_prefix, documents, indexed_dataset,
    method __len__ (line 106) | def __len__(self):
    method __getitem__ (line 111) | def __getitem__(self, idx):
  function _build_index_mappings (line 140) | def _build_index_mappings(name, data_prefix, documents, sizes,
  function _num_tokens (line 231) | def _num_tokens(documents, sizes):
  function _num_epochs (line 236) | def _num_epochs(tokens_per_epoch, seq_length, num_samples):
  function _build_doc_idx (line 251) | def _build_doc_idx(documents, num_epochs, np_rng):
  function _build_sample_idx (line 262) | def _build_sample_idx(sizes, doc_idx, seq_length,
  function _build_shuffle_idx (line 311) | def _build_shuffle_idx(size, np_rng):

FILE: CPM-Generate/data/helpers.cpp
  function build_sample_idx (line 36) | py::array build_sample_idx(const py::array_t<int32_t>& sizes_,
  function get_target_sample_len (line 125) | inline int32_t get_target_sample_len(const int32_t short_seq_ratio,
  function build_mapping_impl (line 138) | py::array build_mapping_impl(const py::array_t<int64_t>& docs_,
  function build_mapping (line 370) | py::array build_mapping(const py::array_t<int64_t>& docs_,
  function PYBIND11_MODULE (line 397) | PYBIND11_MODULE(helpers, m) {

FILE: CPM-Generate/data/indexed_dataset.py
  function __best_fitting_dtype (line 24) | def __best_fitting_dtype(vocab_size=None):
  function get_available_dataset_impl (line 31) | def get_available_dataset_impl():
  function infer_dataset_impl (line 35) | def infer_dataset_impl(path):
  function make_builder (line 51) | def make_builder(out_file, impl, vocab_size=None):
  function make_dataset (line 58) | def make_dataset(path, impl, skip_warmup=False):
  function dataset_exists (line 75) | def dataset_exists(path, impl):
  function read_longs (line 82) | def read_longs(f, n):
  function write_longs (line 88) | def write_longs(f, a):
  function code (line 104) | def code(dtype):
  function index_file_path (line 111) | def index_file_path(prefix_path):
  function data_file_path (line 115) | def data_file_path(prefix_path):
  function create_doc_idx (line 119) | def create_doc_idx(sizes):
  class IndexedDataset (line 127) | class IndexedDataset(torch.utils.data.Dataset):
    method __init__ (line 131) | def __init__(self, path):
    method read_index (line 137) | def read_index(self, path):
    method read_data (line 155) | def read_data(self, path):
    method check_index (line 158) | def check_index(self, i):
    method __del__ (line 162) | def __del__(self):
    method __getitem__ (line 167) | def __getitem__(self, idx):
    method __len__ (line 191) | def __len__(self):
    method num_tokens (line 194) | def num_tokens(self, index):
    method size (line 197) | def size(self, index):
    method exists (line 201) | def exists(path):
    method supports_prefetch (line 207) | def supports_prefetch(self):
  class IndexedCachedDataset (line 211) | class IndexedCachedDataset(IndexedDataset):
    method __init__ (line 213) | def __init__(self, path):
    method supports_prefetch (line 219) | def supports_prefetch(self):
    method prefetch (line 222) | def prefetch(self, indices):
    method __getitem__ (line 247) | def __getitem__(self, idx):
  class IndexedDatasetBuilder (line 264) | class IndexedDatasetBuilder(object):
    method __init__ (line 275) | def __init__(self, out_file, dtype=np.int32):
    method add_item (line 284) | def add_item(self, tensor):
    method end_document (line 291) | def end_document(self):
    method merge_file_ (line 294) | def merge_file_(self, another_file):
    method finalize (line 314) | def finalize(self, index_file):
  function _warmup_mmap_file (line 329) | def _warmup_mmap_file(path):
  class MMapIndexedDataset (line 335) | class MMapIndexedDataset(torch.utils.data.Dataset):
    class Index (line 336) | class Index(object):
      method writer (line 340) | def writer(cls, path, dtype):
      method __init__ (line 385) | def __init__(self, path, skip_warmup=False):
      method __del__ (line 422) | def __del__(self):
      method dtype (line 427) | def dtype(self):
      method sizes (line 431) | def sizes(self):
      method doc_idx (line 435) | def doc_idx(self):
      method __getitem__ (line 439) | def __getitem__(self, i):
      method __len__ (line 442) | def __len__(self):
    method __init__ (line 445) | def __init__(self, path, skip_warmup=False):
    method __getstate__ (line 454) | def __getstate__(self):
    method __setstate__ (line 457) | def __setstate__(self, state):
    method _do_init (line 460) | def _do_init(self, path, skip_warmup):
    method __del__ (line 472) | def __del__(self):
    method __len__ (line 477) | def __len__(self):
    method __getitem__ (line 481) | def __getitem__(self, idx):
    method get (line 500) | def get(self, idx, offset=0, length=None):
    method sizes (line 515) | def sizes(self):
    method doc_idx (line 519) | def doc_idx(self):
    method get_doc_idx (line 522) | def get_doc_idx(self):
    method set_doc_idx (line 525) | def set_doc_idx(self, doc_idx_):
    method supports_prefetch (line 529) | def supports_prefetch(self):
    method exists (line 533) | def exists(path):
  class MMapIndexedDatasetBuilder (line 539) | class MMapIndexedDatasetBuilder(object):
    method __init__ (line 540) | def __init__(self, out_file, dtype=np.int64):
    method add_item (line 546) | def add_item(self, tensor):
    method end_document (line 551) | def end_document(self):
    method merge_file_ (line 554) | def merge_file_(self, another_file):
    method finalize (line 566) | def finalize(self, index_file):

FILE: CPM-Generate/data/samplers.py
  class RandomSampler (line 22) | class RandomSampler(data.sampler.Sampler):
    method __init__ (line 35) | def __init__(self, data_source, replacement=False, num_samples=None):
    method num_samples (line 55) | def num_samples(self):
    method __iter__ (line 61) | def __iter__(self):
    method __len__ (line 71) | def __len__(self):
    method set_epoch (line 74) | def set_epoch(self, epoch):
  class DistributedBatchSampler (line 78) | class DistributedBatchSampler(data.sampler.BatchSampler):
    method __init__ (line 95) | def __init__(self, sampler, batch_size, drop_last, rank=-1,
    method __iter__ (line 110) | def __iter__(self):
    method data_iterator (line 132) | def data_iterator(self, _iter, wrap_around=False):
    method _batch (line 142) | def _batch(self, batch):

FILE: CPM-Generate/data/test/test_indexed_dataset.py
  function test_indexed_dataset (line 17) | def test_indexed_dataset(args):
  function test_indexed_dataset_get (line 43) | def test_indexed_dataset_get(args):
  function main (line 82) | def main():

FILE: CPM-Generate/data_utils/__init__.py
  function should_split (line 29) | def should_split(split):
  function get_ext (line 40) | def get_ext(path):
  function get_dataset (line 44) | def get_dataset(path, **kwargs):
  function supported_corpus (line 57) | def supported_corpus(corpus_name):
  function make_dataset (line 61) | def make_dataset(path, seq_length, text_key, label_key, lazy=False, proc...

FILE: CPM-Generate/data_utils/corpora.py
  class wikipedia (line 19) | class wikipedia(json_dataset):
    method __init__ (line 27) | def __init__(self, **kwargs):
  class webtext (line 37) | class webtext(json_dataset):
    method __init__ (line 45) | def __init__(self, **kwargs):

FILE: CPM-Generate/data_utils/datasets.py
  class ConcatDataset (line 37) | class ConcatDataset(data.Dataset):
    method cumsum (line 48) | def cumsum(sequence):
    method __init__ (line 56) | def __init__(self, datasets, **kwargs):
    method SetTokenizer (line 66) | def SetTokenizer(self, tokenizer):
    method GetTokenizer (line 70) | def GetTokenizer(self):
    method __len__ (line 73) | def __len__(self):
    method __getitem__ (line 76) | def __getitem__(self, idx):
    method lens (line 85) | def lens(self):
    method X (line 97) | def X(self):
    method Y (line 105) | def Y(self):
    method cummulative_sizes (line 114) | def cummulative_sizes(self):
  class SplitDataset (line 119) | class SplitDataset(data.Dataset):
    method __init__ (line 129) | def __init__(self, ds, split_inds, **kwargs):
    method __len__ (line 138) | def __len__(self):
    method __getitem__ (line 141) | def __getitem__(self, index):
    method SetTokenizer (line 144) | def SetTokenizer(self, tokenizer):
    method GetTokenizer (line 147) | def GetTokenizer(self):
    method X (line 151) | def X(self):
    method Y (line 157) | def Y(self):
    method __iter__ (line 162) | def __iter__(self):
  function split_ds (line 166) | def split_ds(ds, split=[.8,.2,.0], shuffle=True):
  class csv_dataset (line 199) | class csv_dataset(data.Dataset):
    method __init__ (line 217) | def __init__(self, path, tokenizer=None, preprocess_fn=None, delim=',',
    method SetTokenizer (line 256) | def SetTokenizer(self, tokenizer):
    method GetTokenizer (line 265) | def GetTokenizer(self):
    method tokenizer (line 269) | def tokenizer(self):
    method __len__ (line 274) | def __len__(self):
    method __getitem__ (line 277) | def __getitem__(self, index):
    method write (line 292) | def write(self, writer_gen=None, path=None, skip_header=False):
  class json_dataset (line 315) | class json_dataset(data.Dataset):
    method __init__ (line 330) | def __init__(self, path, tokenizer=None, preprocess_fn=None, binarize_...
    method SetTokenizer (line 350) | def SetTokenizer(self, tokenizer):
    method GetTokenizer (line 359) | def GetTokenizer(self):
    method tokenizer (line 363) | def tokenizer(self):
    method __getitem__ (line 368) | def __getitem__(self, index):
    method __len__ (line 383) | def __len__(self):
    method write (line 386) | def write(self, writer_gen=None, path=None, skip_header=False):
    method save_json_stream (line 427) | def save_json_stream(self, save_path, json_stream):
    method load_json_stream (line 440) | def load_json_stream(self, load_path):
  class GPT2Dataset (line 456) | class GPT2Dataset(data.Dataset):
    method __init__ (line 458) | def __init__(self, ds,
    method init_weighting (line 479) | def init_weighting(self):
    method get_weighted_samples (line 491) | def get_weighted_samples(self, np_rng):
    method __len__ (line 498) | def __len__(self):
    method __getitem__ (line 501) | def __getitem__(self, idx):
    method getidx (line 541) | def getidx(self, data_idx):
    method pad_seq (line 551) | def pad_seq(self, seq):
    method contains_sentence_end (line 557) | def contains_sentence_end(self, tok):
  class bert_sentencepair_dataset (line 567) | class bert_sentencepair_dataset(data.Dataset):
    method __init__ (line 579) | def __init__(self, ds, max_seq_len=512, mask_lm_prob=.15, max_preds_pe...
    method get_weighting (line 600) | def get_weighting(self):
    method get_weighted_samples (line 611) | def get_weighted_samples(self, np_rng):
    method __len__ (line 618) | def __len__(self):
    method __getitem__ (line 621) | def __getitem__(self, idx):
    method sentence_split (line 648) | def sentence_split(self, document):
    method sentence_tokenize (line 659) | def sentence_tokenize(self, sent, sentence_num=0, beginning=False, end...
    method get_doc (line 666) | def get_doc(self, idx):
    method create_random_sentencepair (line 673) | def create_random_sentencepair(self, target_seq_length, rng, np_rng):
    method truncate_seq_pair (line 754) | def truncate_seq_pair(self, a, b, max_seq_len, rng):
    method mask_token (line 785) | def mask_token(self, idx, tokens, types, vocab_words, rng):
    method pad_seq (line 803) | def pad_seq(self, seq):
    method create_masked_lm_predictions (line 810) | def create_masked_lm_predictions(self, a, b, mask_lm_prob, max_preds_p...

FILE: CPM-Generate/data_utils/file_utils.py
  function url_to_filename (line 43) | def url_to_filename(url, etag=None):
  function filename_to_url (line 61) | def filename_to_url(filename, cache_dir=None):
  function cached_path (line 87) | def cached_path(url_or_filename, cache_dir=None):
  function split_s3_path (line 117) | def split_s3_path(url):
  function s3_request (line 130) | def s3_request(func):
  function s3_etag (line 150) | def s3_etag(url):
  function s3_get (line 159) | def s3_get(url, temp_file):
  function http_get (line 166) | def http_get(url, temp_file):
  function get_from_cache (line 178) | def get_from_cache(url, cache_dir=None):
  function read_set_from_file (line 238) | def read_set_from_file(filename):
  function get_file_extension (line 250) | def get_file_extension(path, dot=True, lower=True):

FILE: CPM-Generate/data_utils/lazy_loader.py
  function get_lazy_path (line 25) | def get_lazy_path(path):
  function exists_lazy (line 31) | def exists_lazy(path, data_type='data'):
  function make_lazy (line 44) | def make_lazy(path, strs, data_type='data'):
  function split_strings (line 70) | def split_strings(strings, start, chr_lens):
  class ProcessorTokenizer (line 76) | class ProcessorTokenizer:
    method __init__ (line 81) | def __init__(self, tokenizer, process_fn=None):
    method __call__ (line 85) | def __call__(self, string):
  class lazy_array_loader (line 92) | class lazy_array_loader(object):
    method __init__ (line 110) | def __init__(self, path, data_type='data', mem_map=False, map_fn=None):
    method SetTokenizer (line 129) | def SetTokenizer(self, tokenizer):
    method GetTokenizer (line 141) | def GetTokenizer(self):
    method __getitem__ (line 144) | def __getitem__(self, index):
    method __len__ (line 171) | def __len__(self):
    method file_read (line 174) | def file_read(self, start=0, end=None):

FILE: CPM-Generate/data_utils/samplers.py
  class RandomSampler (line 24) | class RandomSampler(data.sampler.Sampler):
    method __init__ (line 36) | def __init__(self, data_source, replacement=False, num_samples=None):
    method num_samples (line 54) | def num_samples(self):
    method __iter__ (line 60) | def __iter__(self):
    method __len__ (line 69) | def __len__(self):
    method set_epoch (line 72) | def set_epoch(self, epoch):
  class DistributedBatchSampler (line 75) | class DistributedBatchSampler(data.sampler.BatchSampler):
    method __init__ (line 81) | def __init__(self, sampler, batch_size, drop_last, rank=-1, world_size...
    method __iter__ (line 93) | def __iter__(self):
    method data_iterator (line 125) | def data_iterator(self, _iter, wrap_around=False):
    method _batch (line 135) | def _batch(self, batch):

FILE: CPM-Generate/data_utils/tf_dl.py
  class TFRecordDataLoader (line 25) | class TFRecordDataLoader(object):
    method __init__ (line 26) | def __init__(self, records, batch_size, max_seq_len, max_preds_per_seq...
    method __iter__ (line 65) | def __iter__(self):
  class Record2Example (line 75) | class Record2Example(object):
    method __init__ (line 76) | def __init__(self, feature_map):
    method __call__ (line 79) | def __call__(self, record):
  function convert_tf_example_to_torch_tensors (line 87) | def convert_tf_example_to_torch_tensors(example):
  class MultiprocessLoader (line 100) | class MultiprocessLoader(object):
    method __init__ (line 101) | def __init__(self, dataloader, num_workers=2):
    method __iter__ (line 105) | def __iter__(self):
  function _multiproc_iter (line 117) | def _multiproc_iter(dl, output_queue):

FILE: CPM-Generate/data_utils/tokenization.py
  function make_tokenizer (line 31) | def make_tokenizer(tokenizer_type, corpus, model_path=None, vocab_size=N...
  class Tokenization (line 46) | class Tokenization(object):
    method __init__ (line 57) | def __init__(self, tokenization, text=None, original_text=None, comman...
    method set_command_tokens (line 69) | def set_command_tokens(self, command_tokens):
    method parse_command_tokens (line 73) | def parse_command_tokens(self):
    method __getitem__ (line 82) | def __getitem__(self, index):
    method __len__ (line 85) | def __len__(self):
    method insert (line 88) | def insert(self, idx, other):
    method append (line 102) | def append(self, other):
    method extend (line 115) | def extend(self, other):
  function prep_command_tokens (line 137) | def prep_command_tokens(tokenlist, token_format=token_format):
  class CommandToken (line 140) | class CommandToken(object):
    method __init__ (line 141) | def __init__(self, name, token, Id):
    method __str__ (line 146) | def __str__(self):
  function prep_type_tokens (line 165) | def prep_type_tokens(tokenlist, token_format=token_format):
  class TypeToken (line 168) | class TypeToken(object):
    method __init__ (line 169) | def __init__(self, name, token, Id):
    method __str__ (line 174) | def __str__(self):
  class Tokenizer (line 192) | class Tokenizer(object):
    method __init__ (line 202) | def __init__(self, text_tokenizer, command_tokens=None, type_tokens=No...
    method __call__ (line 245) | def __call__(self, text, process_fn=None):
    method __len__ (line 249) | def __len__(self):
    method get_command (line 253) | def get_command(self, name):
    method get_type (line 257) | def get_type(self, name):
    method tokens (line 262) | def tokens(self):
    method vocab (line 267) | def vocab(self):
    method token_types (line 272) | def token_types(self):
    method token_type_vocab (line 277) | def token_type_vocab(self):
    method command_tokens (line 282) | def command_tokens(self):
    method command_token_vocab (line 287) | def command_token_vocab(self):
    method text_tokens (line 292) | def text_tokens(self):
    method text_token_vocab (line 297) | def text_token_vocab(self):
    method EncodeAsIds (line 301) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 310) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 318) | def IdToToken(self, Id, type_token=False):
    method TokenToId (line 328) | def TokenToId(self, token, type_token=False):
    method DecodeIds (line 338) | def DecodeIds(self, Ids, type_token=False):
    method DecodeTokens (line 364) | def DecodeTokens(self, Tokens, type_token=False):
  class TextTokenizer (line 389) | class TextTokenizer(object):
    method __init__ (line 393) | def __init__(self):
    method __call__ (line 399) | def __call__(self, text, process_fn=None):
    method __len__ (line 402) | def __len__(self):
    method tokens (line 406) | def tokens(self):
    method vocab (line 411) | def vocab(self):
    method exists (line 416) | def exists(model_path):
    method Train (line 420) | def Train(self, corpus):
    method EncodeAsIds (line 424) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 431) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 438) | def IdToToken(self, Id):
    method TokenToId (line 442) | def TokenToId(self, token):
    method DecodeIds (line 446) | def DecodeIds(self, Ids):
    method DecodeTokens (line 450) | def DecodeTokens(self, Tokens):
  class CharacterLevelTokenizer (line 455) | class CharacterLevelTokenizer(TextTokenizer):
    method __init__ (line 459) | def __init__(self, **kwargs):
    method __len__ (line 465) | def __len__(self):
    method exists (line 469) | def exists(model_path):
    method Train (line 472) | def Train(self, corpus):
    method tokens (line 476) | def tokens(self):
    method vocab (line 480) | def vocab(self):
    method EncodeAsIds (line 483) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 492) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 501) | def IdToToken(self, Id):
    method TokenToId (line 505) | def TokenToId(self, token):
    method DecodeIds (line 509) | def DecodeIds(self, Ids):
    method DecodeTokens (line 515) | def DecodeTokens(self, Tokens):
  function get_corpus_freq (line 524) | def get_corpus_freq(dataset, filepath, filetype='tsv'):
  class SentencePieceTokenizer (line 576) | class SentencePieceTokenizer(TextTokenizer):
    method __init__ (line 578) | def __init__(self, model_type='bpe', vocab_size=None, corpus=None, mod...
    method __len__ (line 592) | def __len__(self):
    method tokens (line 596) | def tokens(self):
    method vocab (line 600) | def vocab(self):
    method exists (line 604) | def exists(model_path):
    method load_spm_model (line 614) | def load_spm_model(self):
    method Train (line 624) | def Train(self, corpus, num_text_tokens):
    method EncodeAsIds (line 651) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 659) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 667) | def IdToToken(self, Id):
    method TokenToId (line 671) | def TokenToId(self, token):
    method DecodeIds (line 675) | def DecodeIds(self, Ids):
    method DecodeTokens (line 681) | def DecodeTokens(self, Tokens):
  class BertWordPieceTokenizer (line 687) | class BertWordPieceTokenizer(Tokenizer):
    method __init__ (line 692) | def __init__(self, tokenizer_model_type=None, cache_dir=None, **kwargs):
    method EncodeAsIds (line 745) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 754) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 762) | def IdToToken(self, Id, type_token=False):
    method TokenToId (line 770) | def TokenToId(self, token, type_token=False):
    method DecodeIds (line 778) | def DecodeIds(self, Ids, type_token=False):
    method DecodeTokens (line 790) | def DecodeTokens(self, Tokens, type_token=False):
  class GPT2BPETokenizer (line 799) | class GPT2BPETokenizer(Tokenizer):
    method __init__ (line 800) | def __init__(self, cache_dir=None, **kwargs):
    method EncodeAsIds (line 839) | def EncodeAsIds(self, text, process_fn=None):
    method EncodeAsTokens (line 850) | def EncodeAsTokens(self, text, process_fn=None):
    method IdToToken (line 863) | def IdToToken(self, Id, type_token=False):
    method TokenToId (line 870) | def TokenToId(self, token, type_token=False):
    method DecodeIds (line 877) | def DecodeIds(self, Ids, type_token=False):
    method DecodeTokens (line 884) | def DecodeTokens(self, Tokens, type_token=False):

FILE: CPM-Generate/data_utils/tokenization_gpt2.py
  function lru_cache (line 33) | def lru_cache():
  function bytes_to_unicode (line 54) | def bytes_to_unicode():
  function get_pairs (line 76) | def get_pairs(word):
  class GPT2Tokenizer (line 88) | class GPT2Tokenizer(object):
    method from_pretrained (line 94) | def from_pretrained(cls, pretrained_model_name_or_path, cache_dir=None...
    method __init__ (line 146) | def __init__(self, vocab_file, merges_file, model_file, errors='replac...
    method vocab_size (line 173) | def vocab_size(self):
    method __len__ (line 176) | def __len__(self):
    method eod (line 180) | def eod(self):
    method set_special_tokens (line 183) | def set_special_tokens(self, special_tokens):
    method bpe (line 196) | def bpe(self, token):
    method tokenize (line 237) | def tokenize(self, text):
    method convert_tokens_to_ids (line 246) | def convert_tokens_to_ids(self, tokens):
    method convert_ids_to_tokens (line 267) | def convert_ids_to_tokens(self, ids, skip_special_tokens=False):
    method encode (line 278) | def encode(self, text):
    method decode (line 282) | def decode(self, tokens):
    method save_vocabulary (line 288) | def save_vocabulary(self, vocab_path):

FILE: CPM-Generate/data_utils/wordpiece.py
  function load_vocab (line 50) | def load_vocab(vocab_file):
  function whitespace_tokenize (line 65) | def whitespace_tokenize(text):
  class BertTokenizer (line 74) | class BertTokenizer(object):
    method __init__ (line 77) | def __init__(self, vocab_file, do_lower_case=True, max_len=None, do_ba...
    method tokenize (line 107) | def tokenize(self, text):
    method convert_tokens_to_ids (line 117) | def convert_tokens_to_ids(self, tokens):
    method convert_ids_to_tokens (line 130) | def convert_ids_to_tokens(self, ids):
    method from_pretrained (line 138) | def from_pretrained(cls, pretrained_model_name_or_path, cache_dir=None...
  class BasicTokenizer (line 176) | class BasicTokenizer(object):
    method __init__ (line 179) | def __init__(self,
    method tokenize (line 190) | def tokenize(self, text):
    method _run_strip_accents (line 211) | def _run_strip_accents(self, text):
    method _run_split_on_punc (line 222) | def _run_split_on_punc(self, text):
    method _tokenize_chinese_chars (line 244) | def _tokenize_chinese_chars(self, text):
    method _is_chinese_char (line 257) | def _is_chinese_char(self, cp):
    method _clean_text (line 279) | def _clean_text(self, text):
  class WordpieceTokenizer (line 293) | class WordpieceTokenizer(object):
    method __init__ (line 296) | def __init__(self, vocab, unk_token="[UNK]", max_input_chars_per_word=...
    method tokenize (line 301) | def tokenize(self, text):
  function _is_whitespace (line 353) | def _is_whitespace(char):
  function _is_control (line 365) | def _is_control(char):
  function _is_punctuation (line 377) | def _is_punctuation(char):

FILE: CPM-Generate/fp16/fp16.py
  function conversion_helper (line 28) | def conversion_helper(val, conversion):
  function fp32_to_fp16 (line 37) | def fp32_to_fp16(val):
  function fp16_to_fp32 (line 48) | def fp16_to_fp32(val):
  class FP16_Module (line 59) | class FP16_Module(nn.Module):
    method __init__ (line 60) | def __init__(self, module):
    method forward (line 64) | def forward(self, *inputs, **kwargs):
    method state_dict (line 67) | def state_dict(self, destination=None, prefix='', keep_vars=False):
    method load_state_dict (line 70) | def load_state_dict(self, state_dict, strict=True):
  class FP16_Optimizer (line 74) | class FP16_Optimizer(object):
    method __init__ (line 168) | def __init__(self,
    method maybe_print (line 242) | def maybe_print(self, msg):
    method __getstate__ (line 246) | def __getstate__(self):
    method __setstate__ (line 249) | def __setstate__(self, state):
    method zero_grad (line 252) | def zero_grad(self, set_grads_to_None=False):
    method _check_overflow (line 278) | def _check_overflow(self):
    method _update_scale (line 288) | def _update_scale(self, has_overflow=False):
    method _master_params_to_model_params (line 291) | def _master_params_to_model_params(self):
    method _model_params_to_master_params (line 295) | def _model_params_to_master_params(self):
    method _model_grads_to_master_grads (line 301) | def _model_grads_to_master_grads(self):
    method _downscale_master (line 305) | def _downscale_master(self):
    method clip_master_grads (line 312) | def clip_master_grads(self, max_norm, norm_type=2):
    method state_dict (line 336) | def state_dict(self):
    method load_state_dict (line 357) | def load_state_dict(self, state_dict):
    method step (line 399) | def step(self, closure=None): # could add clip option.
    method _step_with_closure (line 455) | def _step_with_closure(self, closure):
    method backward (line 494) | def backward(self, loss, update_master_grads=True, retain_graph=False):
    method update_master_grads (line 556) | def update_master_grads(self):
    method inspect_master_grad_data (line 569) | def inspect_master_grad_data(self):
    method _get_loss_scale (line 604) | def _get_loss_scale(self):
    method _set_loss_scale (line 607) | def _set_loss_scale(self, value):
    method _get_state (line 613) | def _get_state(self):
    method _set_state (line 616) | def _set_state(self, value):
    method _get_param_groups (line 623) | def _get_param_groups(self):
    method _set_param_groups (line 626) | def _set_param_groups(self, value):

FILE: CPM-Generate/fp16/fp16util.py
  class tofp16 (line 24) | class tofp16(nn.Module):
    method __init__ (line 32) | def __init__(self):
    method forward (line 35) | def forward(self, input):
  function BN_convert_float (line 39) | def BN_convert_float(module):
  function network_to_half (line 52) | def network_to_half(network):
  function convert_module (line 61) | def convert_module(module, dtype):
  function convert_network (line 77) | def convert_network(network, dtype):
  class FP16Model (line 88) | class FP16Model(nn.Module):
    method __init__ (line 93) | def __init__(self, network):
    method forward (line 97) | def forward(self, *inputs):
  function backwards_debug_hook (line 102) | def backwards_debug_hook(grad):
  function prep_param_lists (line 105) | def prep_param_lists(model, flat_master=False):
  function model_grads_to_master_grads (line 151) | def model_grads_to_master_grads(model_params, master_params, flat_master...
  function master_params_to_model_params (line 173) | def master_params_to_model_params(model_params, master_params, flat_mast...
  function to_python_float (line 191) | def to_python_float(t):

FILE: CPM-Generate/fp16/loss_scaler.py
  function to_python_float (line 20) | def to_python_float(t):
  class LossScaler (line 26) | class LossScaler:
    method __init__ (line 38) | def __init__(self, scale=1):
    method has_overflow (line 42) | def has_overflow(self, params):
    method _has_inf_or_nan (line 46) | def _has_inf_or_nan(x):
    method update_scale (line 49) | def update_scale(self, overflow):
    method loss_scale (line 53) | def loss_scale(self):
    method scale_gradient (line 56) | def scale_gradient(self, module, grad_in, grad_out):
    method backward (line 59) | def backward(self, loss, retain_graph=False):
  class DynamicLossScaler (line 63) | class DynamicLossScaler:
    method __init__ (line 89) | def __init__(self,
    method has_overflow_serial (line 107) | def has_overflow_serial(self, params):
    method has_overflow (line 114) | def has_overflow(self, params):
    method _has_inf_or_nan (line 127) | def _has_inf_or_nan(x):
    method update_scale (line 148) | def update_scale(self, overflow):
    method loss_scale (line 175) | def loss_scale(self):
    method scale_gradient (line 178) | def scale_gradient(self, module, grad_in, grad_out):
    method backward (line 181) | def backward(self, loss, retain_graph=False):

FILE: CPM-Generate/generate_samples.py
  function get_masks_and_position_ids (line 39) | def get_masks_and_position_ids(data,
  function initialize_distributed (line 92) | def initialize_distributed(args):
  function set_random_seed (line 113) | def set_random_seed(seed):
  function get_batch (line 122) | def get_batch(context_tokens, device, args):
  function top_k_logits (line 136) | def top_k_logits(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
  function generate_samples (line 164) | def generate_samples(model, tokenizer, args, device):
  function prepare_tokenizer (line 261) | def prepare_tokenizer(args):
  function get_model (line 285) | def get_model(args):
  function setup_model (line 324) | def setup_model(args):
  function main (line 333) | def main():

FILE: CPM-Generate/model/distributed.py
  class DistributedDataParallel (line 24) | class DistributedDataParallel(Module):
    method __init__ (line 26) | def __init__(self, module):
    method forward (line 76) | def forward(self, *inputs, **kwargs):
    method state_dict (line 80) | def state_dict(self, destination=None, prefix='', keep_vars=False):
    method load_state_dict (line 89) | def load_state_dict(self, state_dict, strict=True):

FILE: CPM-Generate/model/gpt2_modeling.py
  function init_method_normal (line 24) | def init_method_normal(std=0.02):
  class GPT2Model (line 35) | class GPT2Model(torch.nn.Module):
    method __init__ (line 42) | def __init__(self,
    method forward (line 83) | def forward(self, input_ids, position_ids, attention_mask):
  function gpt2_get_params_for_weight_decay_optimization (line 108) | def gpt2_get_params_for_weight_decay_optimization(module):

FILE: CPM-Generate/model/model.py
  function get_params_for_weight_decay_optimization (line 25) | def get_params_for_weight_decay_optimization(module):
  class BertModel (line 45) | class BertModel(torch.nn.Module):
    method __init__ (line 47) | def __init__(self, args):
    method forward (line 78) | def forward(self, input_tokens, token_type_ids=None,
    method state_dict (line 84) | def state_dict(self, destination=None, prefix='', keep_vars=False):
    method load_state_dict (line 88) | def load_state_dict(self, state_dict, strict=True):

FILE: CPM-Generate/model/modeling.py
  function normal_init_method (line 42) | def normal_init_method(mean, std):
  function scaled_init_method (line 47) | def scaled_init_method(mean, std, num_layers):
  function load_tf_weights_in_bert (line 70) | def load_tf_weights_in_bert(model, tf_checkpoint_path):
  function gelu (line 131) | def gelu(x):
  function swish (line 139) | def swish(x):
  class BertConfig (line 145) | class BertConfig(object):
    method __init__ (line 148) | def __init__(self,
    method from_dict (line 216) | def from_dict(cls, json_object):
    method from_json_file (line 224) | def from_json_file(cls, json_file):
    method __repr__ (line 230) | def __repr__(self):
    method to_dict (line 233) | def to_dict(self):
    method to_json_string (line 238) | def to_json_string(self):
  class BertLayerNorm (line 246) | class BertLayerNorm(nn.Module):
    method __init__ (line 247) | def __init__(self, hidden_size, eps=1e-12):
    method forward (line 255) | def forward(self, x):
  class BertEmbeddings (line 261) | class BertEmbeddings(nn.Module):
    method __init__ (line 264) | def __init__(self, config):
    method forward (line 282) | def forward(self, input_ids, token_type_ids=None):
  class BertSelfAttention (line 323) | class BertSelfAttention(nn.Module):
    method __init__ (line 324) | def __init__(self, config):
    method transpose_for_scores (line 340) | def transpose_for_scores(self, x):
    method forward (line 345) | def forward(self, hidden_states, attention_mask):
  class BertSelfOutput (line 376) | class BertSelfOutput(nn.Module):
    method __init__ (line 377) | def __init__(self, config):
    method forward (line 397) | def forward(self, hidden_states, input_tensor):
  class BertAttention (line 410) | class BertAttention(nn.Module):
    method __init__ (line 411) | def __init__(self, config):
    method forward (line 422) | def forward(self, input_tensor, attention_mask):
  class BertIntermediate (line 428) | class BertIntermediate(nn.Module):
    method __init__ (line 429) | def __init__(self, config):
    method forward (line 442) | def forward(self, hidden_states):
  class BertOutput (line 448) | class BertOutput(nn.Module):
    method __init__ (line 449) | def __init__(self, config):
    method forward (line 469) | def forward(self, hidden_states, input_tensor):
  class BertLayer (line 482) | class BertLayer(nn.Module):
    method __init__ (line 483) | def __init__(self, config):
    method forward (line 489) | def forward(self, hidden_states, attention_mask):
  class BertEncoder (line 496) | class BertEncoder(nn.Module):
    method __init__ (line 497) | def __init__(self, config):
    method forward (line 512) | def forward(self, hidden_states, attention_mask, output_all_encoded_la...
  class BertPooler (line 543) | class BertPooler(nn.Module):
    method __init__ (line 544) | def __init__(self, config):
    method forward (line 549) | def forward(self, hidden_states):
  class BertPredictionHeadTransform (line 558) | class BertPredictionHeadTransform(nn.Module):
    method __init__ (line 559) | def __init__(self, config):
    method forward (line 567) | def forward(self, hidden_states):
  class BertLMPredictionHead (line 579) | class BertLMPredictionHead(nn.Module):
    method __init__ (line 580) | def __init__(self, config, bert_model_embedding_weights):
    method forward (line 602) | def forward(self, hidden_states):
  class BertOnlyMLMHead (line 618) | class BertOnlyMLMHead(nn.Module):
    method __init__ (line 619) | def __init__(self, config, bert_model_embedding_weights):
    method forward (line 623) | def forward(self, sequence_output):
  class BertOnlyNSPHead (line 628) | class BertOnlyNSPHead(nn.Module):
    method __init__ (line 629) | def __init__(self, config):
    method forward (line 633) | def forward(self, pooled_output):
  class BertPreTrainingHeads (line 638) | class BertPreTrainingHeads(nn.Module):
    method __init__ (line 639) | def __init__(self, config, bert_model_embedding_weights):
    method forward (line 644) | def forward(self, sequence_output, pooled_output):
  class PreTrainedBertModel (line 654) | class PreTrainedBertModel(nn.Module):
    method __init__ (line 658) | def __init__(self, config, *inputs, **kwargs):
    method init_bert_weights (line 669) | def init_bert_weights(self, module):
    method from_pretrained (line 683) | def from_pretrained(cls, pretrained_model_name, state_dict=None, cache...
  class BertModel (line 797) | class BertModel(PreTrainedBertModel):
    method __init__ (line 841) | def __init__(self, config):
    method forward (line 848) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForPreTraining (line 886) | class BertForPreTraining(PreTrainedBertModel):
    method __init__ (line 936) | def __init__(self, config):
    method forward (line 942) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForMaskedLM (line 958) | class BertForMaskedLM(PreTrainedBertModel):
    method __init__ (line 1000) | def __init__(self, config):
    method forward (line 1006) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForNextSentencePrediction (line 1019) | class BertForNextSentencePrediction(PreTrainedBertModel):
    method __init__ (line 1062) | def __init__(self, config):
    method forward (line 1068) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForSequenceClassification (line 1081) | class BertForSequenceClassification(PreTrainedBertModel):
    method __init__ (line 1126) | def __init__(self, config, num_labels=2):
    method forward (line 1134) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForMultipleChoice (line 1147) | class BertForMultipleChoice(PreTrainedBertModel):
    method __init__ (line 1191) | def __init__(self, config, num_choices=2):
    method forward (line 1199) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForTokenClassification (line 1216) | class BertForTokenClassification(PreTrainedBertModel):
    method __init__ (line 1261) | def __init__(self, config, num_labels=2):
    method forward (line 1277) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...
  class BertForQuestionAnswering (line 1291) | class BertForQuestionAnswering(PreTrainedBertModel):
    method __init__ (line 1338) | def __init__(self, config):
    method forward (line 1354) | def forward(self, input_ids, token_type_ids=None, attention_mask=None,...

FILE: CPM-Generate/mpu/cross_entropy.py
  class _VocabParallelCrossEntropy (line 25) | class _VocabParallelCrossEntropy(torch.autograd.Function):
    method forward (line 28) | def forward(ctx, vocab_parallel_logits, target):
    method backward (line 84) | def backward(ctx, grad_output):
  function vocab_parallel_cross_entropy (line 107) | def vocab_parallel_cross_entropy(vocab_parallel_logits, target):

FILE: CPM-Generate/mpu/data.py
  function _check_data_types (line 26) | def _check_data_types(keys, data, target_dtype):
  function _build_key_size_numel_dictionaries (line 33) | def _build_key_size_numel_dictionaries(keys, data):
  function broadcast_data (line 76) | def broadcast_data(keys, data, datatype):

FILE: CPM-Generate/mpu/grads.py
  function clip_grad_norm (line 28) | def clip_grad_norm(parameters, max_norm, norm_type=2):

FILE: CPM-Generate/mpu/initialize.py
  function initialize_model_parallel (line 30) | def initialize_model_parallel(model_parallel_size_):
  function model_parallel_is_initialized (line 81) | def model_parallel_is_initialized():
  function get_model_parallel_group (line 88) | def get_model_parallel_group():
  function get_data_parallel_group (line 95) | def get_data_parallel_group():
  function get_model_parallel_world_size (line 102) | def get_model_parallel_world_size():
  function get_model_parallel_rank (line 107) | def get_model_parallel_rank():
  function get_model_parallel_src_rank (line 112) | def get_model_parallel_src_rank():
  function get_data_parallel_world_size (line 120) | def get_data_parallel_world_size():
  function get_data_parallel_rank (line 125) | def get_data_parallel_rank():
  function destroy_model_parallel (line 130) | def destroy_model_parallel():

FILE: CPM-Generate/mpu/layers.py
  function _initialize_affine_weight (line 42) | def _initialize_affine_weight(weight, output_size, input_size,
  class VocabParallelEmbedding (line 77) | class VocabParallelEmbedding(torch.nn.Module):
    method __init__ (line 87) | def __init__(self, num_embeddings, embedding_dim,
    method forward (line 117) | def forward(self, input_):
  class ParallelEmbedding (line 136) | class ParallelEmbedding(torch.nn.Module):
    method __init__ (line 146) | def __init__(self, num_embeddings, embedding_dim,
    method forward (line 175) | def forward(self, input_):
  class ColumnParallelLinear (line 185) | class ColumnParallelLinear(torch.nn.Module):
    method __init__ (line 205) | def __init__(self, input_size, output_size, bias=True, gather_output=T...
    method forward (line 239) | def forward(self, input_):
  class RowParallelLinear (line 252) | class RowParallelLinear(torch.nn.Module):
    method __init__ (line 278) | def __init__(self, input_size, output_size, bias=True,
    method forward (line 312) | def forward(self, input_):

FILE: CPM-Generate/mpu/mappings.py
  function _reduce (line 22) | def _reduce(input_):
  function _split (line 36) | def _split(input_):
  function _gather (line 56) | def _gather(input_):
  class _CopyToModelParallelRegion (line 79) | class _CopyToModelParallelRegion(torch.autograd.Function):
    method forward (line 83) | def forward(ctx, input_):
    method backward (line 87) | def backward(ctx, grad_output):
  class _ReduceFromModelParallelRegion (line 91) | class _ReduceFromModelParallelRegion(torch.autograd.Function):
    method forward (line 95) | def forward(ctx, input_):
    method backward (line 99) | def backward(ctx, grad_output):
  class _ScatterToModelParallelRegion (line 103) | class _ScatterToModelParallelRegion(torch.autograd.Function):
    method forward (line 107) | def forward(ctx, input_):
    method backward (line 111) | def backward(ctx, grad_output):
  class _GatherFromModelParallelRegion (line 115) | class _GatherFromModelParallelRegion(torch.autograd.Function):
    method forward (line 119) | def forward(ctx, input_):
    method backward (line 123) | def backward(ctx, grad_output):
  function copy_to_model_parallel_region (line 131) | def copy_to_model_parallel_region(input_):
  function reduce_from_model_parallel_region (line 134) | def reduce_from_model_parallel_region(input_):
  function scatter_to_model_parallel_region (line 137) | def scatter_to_model_parallel_region(input_):
  function gather_from_model_parallel_region (line 140) | def gather_from_model_parallel_region(input_):

FILE: CPM-Generate/mpu/random.py
  function see_memory_usage (line 35) | def see_memory_usage(message, force=False):
  function detach_variable (line 62) | def detach_variable(inputs, device=None):
  function _set_cuda_rng_state (line 85) | def _set_cuda_rng_state(new_state, device=-1):
  class CudaRNGStatesTracker (line 119) | class CudaRNGStatesTracker:
    method __init__ (line 127) | def __init__(self):
    method reset (line 133) | def reset(self):
    method get_states (line 138) | def get_states(self):
    method set_states (line 146) | def set_states(self, states):
    method add (line 151) | def add(self, name, seed):
    method fork (line 169) | def fork(self, name=_MODEL_PARALLEL_RNG_TRACKER_NAME):
  function get_cuda_rng_tracker (line 193) | def get_cuda_rng_tracker():
  function model_parallel_cuda_manual_seed (line 198) | def model_parallel_cuda_manual_seed(seed):
  function get_partition_start (line 236) | def get_partition_start(item):
  function get_partition_size (line 242) | def get_partition_size(item):
  function get_full_inputs (line 248) | def get_full_inputs(tensors):
  class CheckpointFunction (line 273) | class CheckpointFunction(torch.autograd.Function):
    method forward (line 281) | def forward(ctx, run_function, *args):
    method backward (line 332) | def backward(ctx, *args):
  function checkpoint (line 375) | def checkpoint(function, *args):
  function partition_activations_in_checkpoint (line 380) | def partition_activations_in_checkpoint(partition_activation):

FILE: CPM-Generate/mpu/tests/commons.py
  class IdentityLayer (line 25) | class IdentityLayer(torch.nn.Module):
    method __init__ (line 26) | def __init__(self, size, scale=1.0):
    method forward (line 29) | def forward(self):
  function set_random_seed (line 33) | def set_random_seed(seed):
  function initialize_distributed (line 41) | def initialize_distributed(backend='nccl'):
  function print_separator (line 75) | def print_separator(message):

FILE: CPM-Generate/mpu/tests/test_cross_entropy.py
  function torch_cross_entropy (line 31) | def torch_cross_entropy(batch_size, seq_length, vocab_size,
  function mpu_cross_entropy (line 46) | def mpu_cross_entropy(batch_size, seq_length, vocab_size,
  function test_cross_entropy (line 60) | def test_cross_entropy(model_parallel_size):

FILE: CPM-Generate/mpu/tests/test_data.py
  function test_boradcast_data (line 29) | def test_boradcast_data(model_parallel_size):

FILE: CPM-Generate/mpu/tests/test_initialize.py
  function test_initialize_model_parallel (line 26) | def test_initialize_model_parallel(model_parallel_size):
  function test_get_model_parallel_src_rank (line 65) | def test_get_model_parallel_src_rank(model_parallel_size_):

FILE: CPM-Generate/mpu/tests/test_layers.py
  function test_parallel_embedding (line 31) | def test_parallel_embedding(model_parallel_size):
  function test_initialize_affine_weight (line 109) | def test_initialize_affine_weight(model_parallel_size):
  class IdentityLayer2D (line 178) | class IdentityLayer2D(torch.nn.Module):
    method __init__ (line 179) | def __init__(self, m , n):
    method forward (line 183) | def forward(self):
  function test_column_parallel_linear (line 187) | def test_column_parallel_linear(model_parallel_size):
  function test_row_parallel_linear (line 254) | def test_row_parallel_linear(model_parallel_size):
  class IdentityLayer3D (line 319) | class IdentityLayer3D(torch.nn.Module):
    method __init__ (line 320) | def __init__(self, m , n, k):
    method forward (line 324) | def forward(self):
  function parallel_self_attention (line 328) | def parallel_self_attention(model_parallel_size, num_att_heads_per_parti...
  function test_parallel_self_attention (line 361) | def test_parallel_self_attention(model_parallel_size):
  function parallel_transformer (line 412) | def parallel_transformer(model_parallel_size, num_att_heads_per_partition,
  function test_parallel_transformer_layer (line 448) | def test_parallel_transformer_layer(model_parallel_size):

FILE: CPM-Generate/mpu/tests/test_random.py
  function test_set_cuda_rng_state (line 26) | def test_set_cuda_rng_state(model_parallel_size):
  function test_cuda_rng_tracker (line 88) | def test_cuda_rng_tracker(model_parallel_size):
  function test_model_parallel_cuda_manual_seed (line 159) | def test_model_parallel_cuda_manual_seed(model_parallel_size):

FILE: CPM-Generate/mpu/transformer.py
  class GPT2ParallelSelfAttention (line 36) | class GPT2ParallelSelfAttention(torch.nn.Module):
    method __init__ (line 62) | def __init__(self, hidden_size, num_attention_heads,
    method _transpose_for_scores (line 94) | def _transpose_for_scores(self, tensor):
    method forward (line 104) | def forward(self, hidden_states, ltor_mask):
  function gelu_impl (line 153) | def gelu_impl(x):
  function gelu (line 158) | def gelu(x):
  class GPT2ParallelMLP (line 162) | class GPT2ParallelMLP(torch.nn.Module):
    method __init__ (line 181) | def __init__(self, hidden_size, output_dropout_prob, init_method,
    method forward (line 199) | def forward(self, hidden_states):
  class GPT2ParallelTransformerLayer (line 210) | class GPT2ParallelTransformerLayer(torch.nn.Module):
    method __init__ (line 238) | def __init__(self,
    method forward (line 274) | def forward(self, hidden_states, ltor_mask):
  function unscaled_init_method (line 294) | def unscaled_init_method(sigma):
  function scaled_init_method (line 302) | def scaled_init_method(sigma, num_layers):
  class GPT2ParallelTransformer (line 311) | class GPT2ParallelTransformer(torch.nn.Module):
    method __init__ (line 345) | def __init__(self,
    method forward (line 382) | def forward(self, hidden_states, attention_mask):
  class BertParallelSelfAttention (line 411) | class BertParallelSelfAttention(torch.nn.Module):
    method __init__ (line 436) | def __init__(self, hidden_size, num_attention_heads,
    method _transpose_for_scores (line 462) | def _transpose_for_scores(self, tensor):
    method forward (line 472) | def forward(self, hidden_states, attention_mask):
  class BertParallelTransformerOutput (line 518) | class BertParallelTransformerOutput(torch.nn.Module):
    method __init__ (line 521) | def __init__(self, input_size, output_size, dropout_prob,
    method forward (line 533) | def forward(self, hidden_states, input_tensor):
  class BertParallelTransformerLayer (line 541) | class BertParallelTransformerLayer(torch.nn.Module):
    method __init__ (line 572) | def __init__(self,
    method forward (line 607) | def forward(self, hidden_states, attention_mask):

FILE: CPM-Generate/mpu/utils.py
  function ensure_divisibility (line 20) | def ensure_divisibility(numerator, denominator):
  function divide (line 26) | def divide(numerator, denominator):
  function split_tensor_along_last_dim (line 33) | def split_tensor_along_last_dim(tensor, num_partitions,
  class VocabUtility (line 54) | class VocabUtility:
    method vocab_range_from_per_partition_vocab_size (line 60) | def vocab_range_from_per_partition_vocab_size(per_partition_vocab_size,
    method vocab_range_from_global_vocab_size (line 67) | def vocab_range_from_global_vocab_size(global_vocab_size, rank, world_...

FILE: CPM-Generate/utils.py
  function print_rank_0 (line 30) | def print_rank_0(message):
  function print_args (line 38) | def print_args(args):
  function print_params_min_max_norm (line 47) | def print_params_min_max_norm(optimizer, iteration):
  class Timers (line 67) | class Timers:
    class Timer (line 70) | class Timer:
      method __init__ (line 73) | def __init__(self, name):
      method start (line 79) | def start(self):
      method stop (line 86) | def stop(self):
      method reset (line 93) | def reset(self):
      method elapsed (line 98) | def elapsed(self, reset=True):
    method __init__ (line 114) | def __init__(self):
    method __call__ (line 117) | def __call__(self, name):
    method log (line 122) | def log(self, names, normalizer=1.0, reset=True):
  function report_memory (line 133) | def report_memory(name):
  function get_checkpoint_name (line 148) | def get_checkpoint_name(checkpoints_path, iteration, release=False, zero...
  function ensure_directory_exists (line 160) | def ensure_directory_exists(filename):
  function get_checkpoint_tracker_filename (line 166) | def get_checkpoint_tracker_filename(checkpoints_path):
  function save_zero_checkpoint (line 170) | def save_zero_checkpoint(args, iteration, optimizer):
  function save_checkpoint (line 178) | def save_checkpoint(iteration, model, optimizer,
  function save_ds_checkpoint (line 224) | def save_ds_checkpoint(iteration, model, args):
  function get_checkpoint_iteration (line 240) | def get_checkpoint_iteration(args):
  function load_checkpoint_model (line 267) | def load_checkpoint_model(model, args):
  function load_weights (line 302) | def load_weights(src, dst, dst2src=False):
  function load_mlp (line 322) | def load_mlp(our, oai, dst2src=False):
  function load_attention (line 326) | def load_attention(our, oai, dst2src=False):
  function load_transformer_layer (line 330) | def load_transformer_layer(our, oai, dst2src=False):
  function move_weights (line 336) | def move_weights(our, oai, dst2src=False):

FILE: tf2gpt/model.py
  function gelu (line 21) | def gelu(x):
  function get_attention_mask (line 62) | def get_attention_mask(dim):
  function get_dense (line 84) | def get_dense(units, name=None, stddev=0.02):
  class Attention (line 93) | class Attention(tf.keras.layers.Layer):
    method __init__ (line 94) | def __init__(self,
    method call (line 116) | def call(self, x,kv_cache=None, **kwargs):
  class Transformer (line 169) | class Transformer(tf.keras.layers.Layer):
    method __init__ (line 171) | def __init__(self,
    method call (line 199) | def call(self, x, kv_cache=None, **kwargs):
  class PositionEmbedding (line 218) | class PositionEmbedding(tf.keras.layers.Layer):
    method __init__ (line 220) | def __init__(self,
    method call (line 230) | def call(self, x, kv_cache=None, **kwargs):
  class GPT (line 240) | class GPT(tf.keras.Model):
    method __init__ (line 241) | def __init__(self,
    method call (line 270) | def call(self, x, kv_cache=None, use_cache=False, **kwargs):
    method train_step (line 288) | def train_step(self, data,mask=None):
    method eval_step (line 317) | def eval_step(self, data,mask=None):

FILE: utils/gpt2_tokenizer.py
  function lru_cache (line 33) | def lru_cache():
  function bytes_to_unicode (line 54) | def bytes_to_unicode():
  function get_pairs (line 76) | def get_pairs(word):
  class GPT2Tokenizer (line 88) | class GPT2Tokenizer(object):
    method from_pretrained (line 94) | def from_pretrained(cls, pretrained_model_name_or_path, cache_dir=None...
    method __init__ (line 146) | def __init__(self, vocab_file, merges_file, model_file, errors='replac...
    method vocab_size (line 173) | def vocab_size(self):
    method __len__ (line 176) | def __len__(self):
    method eod (line 180) | def eod(self):
    method set_special_tokens (line 183) | def set_special_tokens(self, special_tokens):
    method bpe (line 196) | def bpe(self, token):
    method tokenize (line 237) | def tokenize(self, text):
    method convert_tokens_to_ids (line 246) | def convert_tokens_to_ids(self, tokens):
    method convert_ids_to_tokens (line 267) | def convert_ids_to_tokens(self, ids, skip_special_tokens=False):
    method encode (line 278) | def encode(self, text):
    method decode (line 282) | def decode(self, tokens):
    method save_vocabulary (line 289) | def save_vocabulary(self, vocab_path):

FILE: utils/progress_bar.py
  class ProgressBar (line 7) | class ProgressBar():
    method __init__ (line 8) | def __init__(self,worksum,info="",auto_display=True):
    method startjob (line 13) | def startjob(self):
    method complete (line 15) | def complete(self,num):
    method display_progress_bar (line 20) | def display_progress_bar(self):

FILE: utils/story_helper.py
  function print_warp (line 21) | def print_warp(instr):
  function initize (line 25) | def initize(model_path="./tmp_weight"):
  function sample_gpt (line 29) | def sample_gpt(tokenizer, gpt, sentence, number=1, length=20, p=0.9,k=40...
  class Story (line 48) | class Story():
    method __init__ (line 49) | def __init__(self,beginning,story_max_len=200,context_len=12):
    method response_quality_ok (line 54) | def response_quality_ok(self,response):
    method action (line 59) | def action(self,action):
    method interactive (line 83) | def interactive(self):

FILE: utils/story_util.py
  class Story (line 1) | class Story():
    method __init__ (line 2) | def __init__(self,background,title):
    method add_action (line 7) | def add_action(self,action,action_type,result,summary):
    method to_str (line 10) | def to_str(self):
    method to_dungeon_format (line 18) | def to_dungeon_format(self):
    method to_normal_format (line 27) | def to_normal_format(self):
    method from_file (line 36) | def from_file(self,fname):
    method load_content (line 41) | def load_content(self,content):
  class Stories (line 81) | class Stories():
    method __init__ (line 82) | def __init__(self,fname):