INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Load embedding vectors from a pre - trained token embedding file. | def _load_embedding_serialized(self, pretrained_file_path):
"""Load embedding vectors from a pre-trained token embedding file.
For every unknown token, if its representation `self.unknown_token` is encountered in the
pre-trained token embedding file, index 0 of `self.idx_to_vec` maps to the pre... |
Check that tokens and embedding are in the format for __setitem__. | def _check_vector_update(self, tokens, new_embedding):
"""Check that tokens and embedding are in the format for __setitem__."""
assert self._idx_to_vec is not None, '`idx_to_vec` has not been initialized.'
if not isinstance(tokens, (list, tuple)) or len(tokens) == 1:
assert isinstan... |
Checks if a pre - trained token embedding source name is valid. | def _check_source(cls, source_file_hash, source):
"""Checks if a pre-trained token embedding source name is valid.
Parameters
----------
source : str
The pre-trained token embedding source.
"""
embedding_name = cls.__name__.lower()
if source not in s... |
Creates a user - defined token embedding from a pre - trained embedding file. | def from_file(file_path, elem_delim=' ', encoding='utf8', **kwargs):
"""Creates a user-defined token embedding from a pre-trained embedding file.
This is to load embedding vectors from a user-defined pre-trained token embedding file.
For example, if `elem_delim` = ' ', the expected format of a... |
Serializes the TokenEmbedding to a file specified by file_path. | def serialize(self, file_path, compress=True):
"""Serializes the TokenEmbedding to a file specified by file_path.
TokenEmbedding is serialized by converting the list of tokens, the
array of word embeddings and other metadata to numpy arrays, saving all
in a single (optionally compressed... |
Create a new TokenEmbedding from a serialized one. | def deserialize(cls, file_path, **kwargs):
"""Create a new TokenEmbedding from a serialized one.
TokenEmbedding is serialized by converting the list of tokens, the
array of word embeddings and other metadata to numpy arrays, saving all
in a single (optionally compressed) Zipfile. See
... |
Evaluate the model on a mini - batch. | def evaluate(data_source):
"""Evaluate the model on a mini-batch.
"""
log.info('Start predict')
tic = time.time()
for batch in data_source:
inputs, token_types, valid_length = batch
out = net(inputs.astype('float32').as_in_context(ctx),
token_types.astype('float32')... |
Registers a dataset with segment specific hyperparameters. | def register(class_=None, **kwargs):
"""Registers a dataset with segment specific hyperparameters.
When passing keyword arguments to `register`, they are checked to be valid
keyword arguments for the registered Dataset class constructor and are
saved in the registry. Registered keyword arguments can be... |
Creates an instance of a registered dataset. | def create(name, **kwargs):
"""Creates an instance of a registered dataset.
Parameters
----------
name : str
The dataset name (case-insensitive).
Returns
-------
An instance of :class:`mxnet.gluon.data.Dataset` constructed with the
keyword arguments passed to the create functio... |
Get valid datasets and registered parameters. | def list_datasets(name=None):
"""Get valid datasets and registered parameters.
Parameters
----------
name : str or None, default None
Return names and registered parameters of registered datasets. If name
is specified, only registered parameters of the respective dataset are
ret... |
Parse command line arguments. | def parse_args():
"""Parse command line arguments."""
parser = argparse.ArgumentParser(
description='Vocabulary extractor.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--max-size', type=int, default=None)
parser.add_argument('--min-freq', type=int, defau... |
Compute the vocabulary. | def get_vocab(args):
"""Compute the vocabulary."""
counter = nlp.data.Counter()
start = time.time()
for filename in args.files:
print('Starting processing of {} after {:.1f} seconds.'.format(
filename,
time.time() - start))
with open(filename, 'r') as f:
... |
Generate the unnormalized score for the given the input sequences. | def forward(self, inputs, token_types, valid_length=None): # pylint: disable=arguments-differ
"""Generate the unnormalized score for the given the input sequences.
Parameters
----------
inputs : NDArray, shape (batch_size, seq_length)
Input words for the sequences.
... |
Add evaluation specific parameters to parser. | def add_parameters(parser):
"""Add evaluation specific parameters to parser."""
group = parser.add_argument_group('Evaluation arguments')
group.add_argument('--eval-batch-size', type=int, default=1024)
# Datasets
group.add_argument(
'--similarity-datasets', type=str,
default=nlp.da... |
Validate provided arguments and act on -- help. | def validate_args(args):
"""Validate provided arguments and act on --help."""
# Check correctness of similarity dataset names
for dataset_name in args.similarity_datasets:
if dataset_name.lower() not in map(
str.lower,
nlp.data.word_embedding_evaluation.word_similarit... |
Generator over all similarity evaluation datasets. | def iterate_similarity_datasets(args):
"""Generator over all similarity evaluation datasets.
Iterates over dataset names, keyword arguments for their creation and the
created dataset.
"""
for dataset_name in args.similarity_datasets:
parameters = nlp.data.list_datasets(dataset_name)
... |
Generator over all analogy evaluation datasets. | def iterate_analogy_datasets(args):
"""Generator over all analogy evaluation datasets.
Iterates over dataset names, keyword arguments for their creation and the
created dataset.
"""
for dataset_name in args.analogy_datasets:
parameters = nlp.data.list_datasets(dataset_name)
for key... |
Returns a set of all tokens occurring the evaluation datasets. | def get_similarity_task_tokens(args):
"""Returns a set of all tokens occurring the evaluation datasets."""
tokens = set()
for _, _, dataset in iterate_similarity_datasets(args):
tokens.update(
itertools.chain.from_iterable((d[0], d[1]) for d in dataset))
return tokens |
Returns a set of all tokens occuring the evaluation datasets. | def get_analogy_task_tokens(args):
"""Returns a set of all tokens occuring the evaluation datasets."""
tokens = set()
for _, _, dataset in iterate_analogy_datasets(args):
tokens.update(
itertools.chain.from_iterable(
(d[0], d[1], d[2], d[3]) for d in dataset))
return ... |
Evaluate on specified similarity datasets. | def evaluate_similarity(args, token_embedding, ctx, logfile=None,
global_step=0):
"""Evaluate on specified similarity datasets."""
results = []
for similarity_function in args.similarity_functions:
evaluator = nlp.embedding.evaluation.WordEmbeddingSimilarity(
idx... |
Evaluate on specified analogy datasets. | def evaluate_analogy(args, token_embedding, ctx, logfile=None, global_step=0):
"""Evaluate on specified analogy datasets.
The analogy task is an open vocabulary task, make sure to pass a
token_embedding with a sufficiently large number of supported tokens.
"""
results = []
exclude_question_wor... |
Log a similarity evaluation result dictionary as TSV to logfile. | def log_similarity_result(logfile, result):
"""Log a similarity evaluation result dictionary as TSV to logfile."""
assert result['task'] == 'similarity'
if not logfile:
return
with open(logfile, 'a') as f:
f.write('\t'.join([
str(result['global_step']),
result['... |
Get model for pre - training. | def get_model_loss(ctx, model, pretrained, dataset_name, dtype, ckpt_dir=None, start_step=None):
"""Get model for pre-training."""
# model
model, vocabulary = nlp.model.get_model(model,
dataset_name=dataset_name,
pretrai... |
create dataset for pretraining. | def get_pretrain_dataset(data, batch_size, num_ctxes, shuffle, use_avg_len,
num_buckets, num_parts=1, part_idx=0, prefetch=True):
"""create dataset for pretraining."""
num_files = len(glob.glob(os.path.expanduser(data)))
logging.debug('%d files found.', num_files)
assert num_fil... |
Return a dummy data loader which returns a fixed data batch of target shape | def get_dummy_dataloader(dataloader, target_shape):
"""Return a dummy data loader which returns a fixed data batch of target shape"""
data_iter = enumerate(dataloader)
_, data_batch = next(data_iter)
logging.debug('Searching target batch shape: %s', target_shape)
while data_batch[0].shape != target_... |
Save the model parameter marked by step_num. | def save_params(step_num, model, trainer, ckpt_dir):
"""Save the model parameter, marked by step_num."""
param_path = os.path.join(ckpt_dir, '%07d.params'%step_num)
trainer_path = os.path.join(ckpt_dir, '%07d.states'%step_num)
logging.info('[step %d] Saving checkpoints to %s, %s.',
step... |
Log training progress. | def log(begin_time, running_num_tks, running_mlm_loss, running_nsp_loss, step_num,
mlm_metric, nsp_metric, trainer, log_interval):
"""Log training progress."""
end_time = time.time()
duration = end_time - begin_time
throughput = running_num_tks / duration / 1000.0
running_mlm_loss = running_... |
split and load arrays to a list of contexts | def split_and_load(arrs, ctx):
"""split and load arrays to a list of contexts"""
assert isinstance(arrs, (list, tuple))
# split and load
loaded_arrs = [mx.gluon.utils.split_and_load(arr, ctx, even_split=False) for arr in arrs]
return zip(*loaded_arrs) |
forward computation for evaluation | def forward(data, model, mlm_loss, nsp_loss, vocab_size, dtype):
"""forward computation for evaluation"""
(input_id, masked_id, masked_position, masked_weight, \
next_sentence_label, segment_id, valid_length) = data
num_masks = masked_weight.sum() + 1e-8
valid_length = valid_length.reshape(-1)
... |
Evaluation function. | def evaluate(data_eval, model, nsp_loss, mlm_loss, vocab_size, ctx, log_interval, dtype):
"""Evaluation function."""
mlm_metric = MaskedAccuracy()
nsp_metric = MaskedAccuracy()
mlm_metric.reset()
nsp_metric.reset()
eval_begin_time = time.time()
begin_time = time.time()
step_num = 0
... |
Argument parser | def get_argparser():
"""Argument parser"""
parser = argparse.ArgumentParser(description='BERT pretraining example.')
parser.add_argument('--num_steps', type=int, default=20, help='Number of optimization steps')
parser.add_argument('--num_buckets', type=int, default=1,
help='Numbe... |
Cache the processed npy dataset the dataset into a npz | def _cache_dataset(dataset, prefix):
"""Cache the processed npy dataset the dataset into a npz
Parameters
----------
dataset : SimpleDataset
file_path : str
"""
if not os.path.exists(_constants.CACHE_PATH):
os.makedirs(_constants.CACHE_PATH)
src_data = np.concatenate([e[0] for e... |
Load translation dataset | def load_translation_data(dataset, bleu, args):
"""Load translation dataset
Parameters
----------
dataset : str
args : argparse result
Returns
-------
"""
src_lang, tgt_lang = args.src_lang, args.tgt_lang
if dataset == 'IWSLT2015':
common_prefix = 'IWSLT2015_{}_{}_{}_{... |
Create data loaders for training/ validation/ test. | def make_dataloader(data_train, data_val, data_test, args,
use_average_length=False, num_shards=0, num_workers=8):
"""Create data loaders for training/validation/test."""
data_train_lengths = get_data_lengths(data_train)
data_val_lengths = get_data_lengths(data_val)
data_test_lengths... |
Method representing the process’s activity. | def run(self):
"""Method representing the process’s activity."""
random.seed(self.seed)
np.random.seed(self.np_seed)
if not isinstance(self, multiprocessing.Process):
# Calling mxnet methods in a subprocess will raise an exception if
# mxnet is built with GPU supp... |
Defines the forward computation. Arguments can be either: py: class: NDArray or: py: class: Symbol. | def forward(self, inputs, states=None): # pylint: disable=arguments-differ
"""Defines the forward computation. Arguments can be either
:py:class:`NDArray` or :py:class:`Symbol`."""
batch_size = inputs.shape[self._batch_axis]
skip_states = states is None
if skip_states:
... |
Compute embedding of words in batch. | def hybrid_forward(self, F, words, weight):
"""Compute embedding of words in batch.
Parameters
----------
words : mx.nd.NDArray
Array of token indices.
"""
#pylint: disable=arguments-differ
embeddings = F.sparse.dot(words, weight)
return embe... |
Create an instance of the class and load weights. | def load_fasttext_format(cls, path, ctx=cpu(), **kwargs):
"""Create an instance of the class and load weights.
Load the weights from the fastText binary format created by
https://github.com/facebookresearch/fastText
Parameters
----------
path : str
Path to t... |
Config the logging. | def logging_config(logpath=None,
level=logging.DEBUG,
console_level=logging.INFO,
no_console=False):
"""
Config the logging.
"""
logger = logging.getLogger('nli')
# Remove all the current handlers
for handler in logger.handlers:
lo... |
Parse command line arguments. | def parse_args():
"""Parse command line arguments."""
parser = argparse.ArgumentParser(
description='GloVe with GluonNLP',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
# Data options
group = parser.add_argument_group('Data arguments')
group.add_argument(
'cooccurr... |
Helper function to get training data. | def get_train_data(args):
"""Helper function to get training data."""
counter = dict()
with io.open(args.vocab, 'r', encoding='utf-8') as f:
for line in f:
token, count = line.split('\t')
counter[token] = int(count)
vocab = nlp.Vocab(counter, unknown_token=None, padding_t... |
Training helper. | def train(args):
"""Training helper."""
vocab, row, col, counts = get_train_data(args)
model = GloVe(token_to_idx=vocab.token_to_idx, output_dim=args.emsize,
dropout=args.dropout, x_max=args.x_max, alpha=args.alpha,
weight_initializer=mx.init.Uniform(scale=1 / args.emsize... |
Log to a file. | def log(args, kwargs):
"""Log to a file."""
logfile = os.path.join(args.logdir, 'log.tsv')
if 'log_created' not in globals():
if os.path.exists(logfile):
logging.error('Logfile %s already exists.', logfile)
sys.exit(1)
global log_created
log_created = sorte... |
Compute embedding of words in batch. | def hybrid_forward(self, F, row, col, counts):
"""Compute embedding of words in batch.
Parameters
----------
row : mxnet.nd.NDArray or mxnet.sym.Symbol
Array of token indices for source words. Shape (batch_size, ).
row : mxnet.nd.NDArray or mxnet.sym.Symbol
... |
Updates the internal evaluation result. | def update(self, labels, preds, masks=None):
# pylint: disable=arguments-differ
"""Updates the internal evaluation result.
Parameters
----------
labels : list of `NDArray`
The labels of the data with class indices as values, one per sample.
preds : list of `N... |
Predict the relation of two sentences. | def hybrid_forward(self, F, sentence1, sentence2):
"""
Predict the relation of two sentences.
Parameters
----------
sentence1 : NDArray
Shape (batch_size, length)
sentence2 : NDArray
Shape (batch_size, length)
Returns
-------
... |
Compute intra - sentence attention given embedded words. | def hybrid_forward(self, F, feature_a):
"""
Compute intra-sentence attention given embedded words.
Parameters
----------
feature_a : NDArray
Shape (batch_size, length, hidden_size)
Returns
-------
alpha : NDArray
Shape (batch_size... |
Forward of Decomposable Attention layer | def hybrid_forward(self, F, a, b):
"""
Forward of Decomposable Attention layer
"""
# a.shape = [B, L1, H]
# b.shape = [B, L2, H]
# extract features
tilde_a = self.f(a) # shape = [B, L1, H]
tilde_b = self.f(b) # shape = [B, L2, H]
# attention
... |
r Counts tokens in the specified string. | def count_tokens(tokens, to_lower=False, counter=None):
r"""Counts tokens in the specified string.
For token_delim='(td)' and seq_delim='(sd)', a specified string of two sequences of tokens may
look like::
(td)token1(td)token2(td)token3(td)(sd)(td)token4(td)token5(td)(sd)
Parameters
----... |
Slice a flat sequence of tokens into sequences tokens with each inner sequence s length equal to the specified length taking into account the requested sequence overlap. | def slice_sequence(sequence, length, pad_last=False, pad_val=C.PAD_TOKEN, overlap=0):
"""Slice a flat sequence of tokens into sequences tokens, with each
inner sequence's length equal to the specified `length`, taking into account the requested
sequence overlap.
Parameters
----------
sequence :... |
Calculate the padding length needed for sliced samples in order not to discard data. | def _slice_pad_length(num_items, length, overlap=0):
"""Calculate the padding length needed for sliced samples in order not to discard data.
Parameters
----------
num_items : int
Number of items in dataset before collating.
length : int
The length of each of the samples.
overlap... |
Split the dataset into training and validation sets. | def train_valid_split(dataset, valid_ratio=0.05):
"""Split the dataset into training and validation sets.
Parameters
----------
dataset : list
A list of training samples.
valid_ratio : float, default 0.05
Proportion of training samples to use for validation set
range: [0, 1]... |
Load the accompanying vocabulary object for pre - trained model. | def _load_pretrained_vocab(name, root=os.path.join(get_home_dir(), 'models'), cls=None):
"""Load the accompanying vocabulary object for pre-trained model.
Parameters
----------
name : str
Name of the vocabulary, usually the name of the dataset.
root : str, default '$MXNET_HOME/models'
... |
Extract archive file | def _extract_archive(file, target_dir):
"""Extract archive file
Parameters
----------
file : str
Absolute path of the archive file.
target_dir : str
Target directory of the archive to be uncompressed
"""
if file.endswith('.gz') or file.endswith('.tar') or file.endswith('.tg... |
Discards tokens with frequency below min_frequency and represents them as unknown_token. | def discard(self, min_freq, unknown_token):
"""Discards tokens with frequency below min_frequency and represents them
as `unknown_token`.
Parameters
----------
min_freq: int
Tokens whose frequency is under min_freq is counted as `unknown_token` in
the Cou... |
Training function. | def train():
"""Training function."""
trainer = gluon.Trainer(model.collect_params(), args.optimizer,
{'learning_rate': args.lr, 'beta2': 0.98, 'epsilon': 1e-9})
train_data_loader, val_data_loader, test_data_loader \
= dataprocessor.make_dataloader(data_train, data_val, ... |
r Forward computation for highway layer | def hybrid_forward(self, F, inputs, **kwargs):
# pylint: disable=unused-argument
r"""
Forward computation for highway layer
Parameters
----------
inputs: NDArray
The input tensor is of shape `(..., input_size)`.
Returns
----------
out... |
Generate the unnormalized score for the given the input sequences. | def forward(self, inputs, token_types, valid_length=None): # pylint: disable=arguments-differ
"""Generate the unnormalized score for the given the input sequences.
Parameters
----------
inputs : NDArray, shape (batch_size, seq_length)
Input words for the sequences.
... |
Defines the forward computation for cache cell. Arguments can be either: py: class: NDArray or: py: class: Symbol. | def hybrid_forward(self, F, inputs, states=None, mask=None):
# pylint: disable=arguments-differ
# pylint: disable=unused-argument
"""Defines the forward computation for cache cell. Arguments can be either
:py:class:`NDArray` or :py:class:`Symbol`.
Parameters
----------
... |
Read tokens from the provided parse tree in the SNLI dataset. Illegal examples are removed. | def main(args):
"""
Read tokens from the provided parse tree in the SNLI dataset.
Illegal examples are removed.
"""
examples = []
with open(args.input, 'r') as fin:
reader = csv.DictReader(fin, delimiter='\t')
for cols in reader:
s1 = read_tokens(cols['sentence1_parse... |
one iteration of k - means | def _recenter(self):
"""
one iteration of k-means
"""
for split_idx in range(len(self._splits)):
split = self._splits[split_idx]
len_idx = self._split2len_idx[split]
if split == self._splits[-1]:
continue
right_split = self.... |
Index every sentence into a cluster | def _reindex(self):
"""
Index every sentence into a cluster
"""
self._len2split_idx = {}
last_split = -1
for split_idx, split in enumerate(self._splits):
self._len2split_idx.update(
dict(list(zip(list(range(last_split + 1, split)), [split_idx] ... |
Build a pair of GNMT encoder/ decoder | def get_gnmt_encoder_decoder(cell_type='lstm', attention_cell='scaled_luong', num_layers=2,
num_bi_layers=1, hidden_size=128, dropout=0.0, use_residual=False,
i2h_weight_initializer=None, h2h_weight_initializer=None,
i2h_bias_initial... |
Initialize the state from the encoder outputs. | def init_state_from_encoder(self, encoder_outputs, encoder_valid_length=None):
"""Initialize the state from the encoder outputs.
Parameters
----------
encoder_outputs : list
encoder_valid_length : NDArray or None
Returns
-------
decoder_states : list
... |
Decode the decoder inputs. This function is only used for training. | def decode_seq(self, inputs, states, valid_length=None):
"""Decode the decoder inputs. This function is only used for training.
Parameters
----------
inputs : NDArray, Shape (batch_size, length, C_in)
states : list of NDArrays or None
Initial states. The list of init... |
Transform instance to inputs for MLM and NSP. | def transform(instance, tokenizer, max_seq_length, max_predictions_per_seq, do_pad=True):
"""Transform instance to inputs for MLM and NSP."""
pad = tokenizer.convert_tokens_to_ids(['[PAD]'])[0]
input_ids = tokenizer.convert_tokens_to_ids(instance.tokens)
input_mask = [1] * len(input_ids)
segment_ids... |
Write to numpy files from TrainingInstance s. | def write_to_files_np(features, tokenizer, max_seq_length,
max_predictions_per_seq, output_files):
# pylint: disable=unused-argument
"""Write to numpy files from `TrainingInstance`s."""
next_sentence_labels = []
valid_lengths = []
assert len(output_files) == 1, 'numpy format o... |
Create IndexedRecordIO files from TrainingInstance s. | def write_to_files_rec(instances, tokenizer, max_seq_length,
max_predictions_per_seq, output_files):
"""Create IndexedRecordIO files from `TrainingInstance`s."""
writers = []
for output_file in output_files:
writers.append(
mx.recordio.MXIndexedRecordIO(
... |
Create TrainingInstance s from raw text. | def create_training_instances(x):
"""Create `TrainingInstance`s from raw text."""
(input_files, out, tokenizer, max_seq_length, dupe_factor,
short_seq_prob, masked_lm_prob, max_predictions_per_seq, rng) = x
time_start = time.time()
logging.info('Processing %s', input_files)
all_documents = [[]]... |
Creates TrainingInstance s for a single document. | def create_instances_from_document(
all_documents, document_index, max_seq_length, short_seq_prob,
masked_lm_prob, max_predictions_per_seq, vocab_words, rng):
"""Creates `TrainingInstance`s for a single document."""
document = all_documents[document_index]
# Account for [CLS], [SEP], [SEP]
... |
Creates the predictions for the masked LM objective. | def create_masked_lm_predictions(tokens, masked_lm_prob,
max_predictions_per_seq, vocab_words, rng):
"""Creates the predictions for the masked LM objective."""
cand_indexes = []
for (i, token) in enumerate(tokens):
if token in ['[CLS]', '[SEP]']:
continu... |
Truncates a pair of sequences to a maximum sequence length. | def truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng):
"""Truncates a pair of sequences to a maximum sequence length."""
while True:
total_length = len(tokens_a) + len(tokens_b)
if total_length <= max_num_tokens:
break
trunc_tokens = tokens_a if len(tokens_a) > len(... |
Main function. | def main():
"""Main function."""
time_start = time.time()
logging.info('loading vocab file from dataset: %s', args.vocab)
vocab_obj = nlp.data.utils._load_pretrained_vocab(args.vocab)
tokenizer = BERTTokenizer(
vocab=vocab_obj, lower='uncased' in args.vocab)
input_files = []
for inp... |
GluonNLP specific code to convert the original vocabulary to nlp. vocab. BERTVocab. | def convert_vocab(vocab_file):
"""GluonNLP specific code to convert the original vocabulary to nlp.vocab.BERTVocab."""
original_vocab = load_vocab(vocab_file)
token_to_idx = dict(original_vocab)
num_tokens = len(token_to_idx)
idx_to_token = [None] * len(original_vocab)
for word in original_vocab... |
read tensorflow checkpoint | def read_tf_checkpoint(path):
"""read tensorflow checkpoint"""
from tensorflow.python import pywrap_tensorflow
tensors = {}
reader = pywrap_tensorflow.NewCheckpointReader(path)
var_to_shape_map = reader.get_variable_to_shape_map()
for key in sorted(var_to_shape_map):
tensor = reader.get_... |
profile the program between [ start_step end_step ). | def profile(curr_step, start_step, end_step, profile_name='profile.json',
early_exit=True):
"""profile the program between [start_step, end_step)."""
if curr_step == start_step:
mx.nd.waitall()
mx.profiler.set_config(profile_memory=False, profile_symbolic=True,
... |
Loads a vocabulary file into a dictionary. | def load_vocab(vocab_file):
"""Loads a vocabulary file into a dictionary."""
vocab = collections.OrderedDict()
index = 0
with io.open(vocab_file, 'r') as reader:
while True:
token = reader.readline()
if not token:
break
token = token.strip()
... |
r Forward computation for char_encoder | def hybrid_forward(self, F, inputs, mask=None): # pylint: disable=arguments-differ
r"""
Forward computation for char_encoder
Parameters
----------
inputs: NDArray
The input tensor is of shape `(seq_len, batch_size, embedding_size)` TNC.
mask: NDArray
... |
Init the sinusoid position encoding table | def _position_encoding_init(max_length, dim):
"""Init the sinusoid position encoding table """
position_enc = np.arange(max_length).reshape((-1, 1)) \
/ (np.power(10000, (2. / dim) * np.arange(dim).reshape((1, -1))))
# Apply the cosine to even columns and sin to odds.
position_enc[:, ... |
Build a pair of Parallel Transformer encoder/ decoder | def get_transformer_encoder_decoder(num_layers=2,
num_heads=8, scaled=True,
units=512, hidden_size=2048, dropout=0.0, use_residual=True,
max_src_length=50, max_tgt_length=50,
w... |
r Transformer pretrained model. | def transformer_en_de_512(dataset_name=None, src_vocab=None, tgt_vocab=None, pretrained=False,
ctx=cpu(), root=os.path.join(get_home_dir(), 'models'), **kwargs):
r"""Transformer pretrained model.
Embedding size is 400, and hidden layer size is 1150.
Parameters
----------
... |
Get activation block based on the name. | def _get_activation(self, act):
"""Get activation block based on the name. """
if isinstance(act, str):
if act.lower() == 'gelu':
return GELU()
else:
return gluon.nn.Activation(act)
assert isinstance(act, gluon.Block)
return act |
Position - wise encoding of the inputs. | def hybrid_forward(self, F, inputs): # pylint: disable=arguments-differ
# pylint: disable=unused-argument
"""Position-wise encoding of the inputs.
Parameters
----------
inputs : Symbol or NDArray
Input sequence. Shape (batch_size, length, C_in)
Returns
... |
Transformer Encoder Attention Cell. | def hybrid_forward(self, F, inputs, mask=None): # pylint: disable=arguments-differ
# pylint: disable=unused-argument
"""Transformer Encoder Attention Cell.
Parameters
----------
inputs : Symbol or NDArray
Input sequence. Shape (batch_size, length, C_in)
mask... |
Transformer Decoder Attention Cell. | def hybrid_forward(self, F, inputs, mem_value, mask=None, mem_mask=None): #pylint: disable=unused-argument
# pylint: disable=arguments-differ
"""Transformer Decoder Attention Cell.
Parameters
----------
inputs : Symbol or NDArray
Input sequence. Shape (batch_size, ... |
Initialize the state from the encoder outputs. | def init_state_from_encoder(self, encoder_outputs, encoder_valid_length=None):
"""Initialize the state from the encoder outputs.
Parameters
----------
encoder_outputs : list
encoder_valid_length : NDArray or None
Returns
-------
decoder_states : list
... |
Decode the decoder inputs. This function is only used for training. | def decode_seq(self, inputs, states, valid_length=None):
"""Decode the decoder inputs. This function is only used for training.
Parameters
----------
inputs : NDArray, Shape (batch_size, length, C_in)
states : list of NDArrays or None
Initial states. The list of deco... |
Perform forward and backward computation for a batch of src seq and dst seq | def forward_backward(self, x):
"""Perform forward and backward computation for a batch of src seq and dst seq"""
(src_seq, tgt_seq, src_valid_length, tgt_valid_length), batch_size = x
with mx.autograd.record():
out, _ = self._model(src_seq, tgt_seq[:, :-1],
... |
Parse arguments. | def parse_args():
"""
Parse arguments.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--gpu-id', type=int, default=0,
help='GPU id (-1 means CPU)')
parser.add_argument('--train-file', default='snli_1.0/snli_1.0_train.txt',
help='traini... |
Train model and validate/ save every epoch. | def train_model(model, train_data_loader, val_data_loader, embedding, ctx, args):
"""
Train model and validate/save every epoch.
"""
logger.info(vars(args))
# Initialization
model.hybridize()
model.collect_params().initialize(mx.init.Normal(0.01), ctx=ctx)
model.word_emb.weight.set_data... |
Entry point: train or test. | def main(args):
"""
Entry point: train or test.
"""
json.dump(vars(args), open(os.path.join(args.output_dir, 'config.json'), 'w'))
if args.gpu_id == -1:
ctx = mx.cpu()
else:
ctx = mx.gpu(args.gpu_id)
mx.random.seed(args.seed, ctx=ctx)
if args.mode == 'train':
t... |
Draw samples from uniform distribution and return sampled candidates. | def hybrid_forward(self, F, candidates_like, prob, alias):
# pylint: disable=unused-argument
"""Draw samples from uniform distribution and return sampled candidates.
Parameters
----------
candidates_like: mxnet.nd.NDArray or mxnet.sym.Symbol
This input specifies the ... |
r Add a handler sending log messages to a sink adequately configured. | def add(
self,
sink,
*,
level=_defaults.LOGURU_LEVEL,
format=_defaults.LOGURU_FORMAT,
filter=_defaults.LOGURU_FILTER,
colorize=_defaults.LOGURU_COLORIZE,
serialize=_defaults.LOGURU_SERIALIZE,
backtrace=_defaults.LOGURU_BACKTRACE,
diagnose=_... |
Remove a previously added handler and stop sending logs to its sink. | def remove(self, handler_id=None):
"""Remove a previously added handler and stop sending logs to its sink.
Parameters
----------
handler_id : |int| or ``None``
The id of the sink to remove, as it was returned by the |add| method. If ``None``, all
handlers are rem... |
Return a decorator to automatically log possibly caught error in wrapped function. | def catch(
self,
exception=Exception,
*,
level="ERROR",
reraise=False,
message="An error has been caught in function '{record[function]}', "
"process '{record[process].name}' ({record[process].id}), "
"thread '{record[thread].name}' ({record[thread].id}):"... |
r Parametrize a logging call to slightly change generated log message. | def opt(self, *, exception=None, record=False, lazy=False, ansi=False, raw=False, depth=0):
r"""Parametrize a logging call to slightly change generated log message.
Parameters
----------
exception : |bool|, |tuple| or |Exception|, optional
If it does not evaluate as ``False`... |
Bind attributes to the extra dict of each logged message record. | def bind(_self, **kwargs):
"""Bind attributes to the ``extra`` dict of each logged message record.
This is used to add custom context to each logging call.
Parameters
----------
**kwargs
Mapping between keys and values that will be added to the ``extra`` dict.
... |
Add update or retrieve a logging level. | def level(self, name, no=None, color=None, icon=None):
"""Add, update or retrieve a logging level.
Logging levels are defined by their ``name`` to which a severity ``no``, an ansi ``color``
and an ``icon`` are associated and possibly modified at run-time. To |log| to a custom
level, you... |
Configure the core logger. | def configure(self, *, handlers=None, levels=None, extra=None, activation=None):
"""Configure the core logger.
It should be noted that ``extra`` values set using this function are available across all
modules, so this is the best way to set overall default values.
Parameters
--... |
Parse raw logs and extract each entry as a |dict|. | def parse(file, pattern, *, cast={}, chunk=2 ** 16):
"""
Parse raw logs and extract each entry as a |dict|.
The logging format has to be specified as the regex ``pattern``, it will then be
used to parse the ``file`` and retrieve each entries based on the named groups present
in ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.