id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
23,600 | apache/incubator-mxnet | example/svrg_module/linear_regression/common.py | calc_expectation | def calc_expectation(grad_dict, num_batches):
"""Calculates the expectation of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients expectations
"""
for key in grad_dict.keys():
grad_dict[str.format(key+"_expectation")] = mx.ndarray.sum(grad_dict[key], axis=0) / num_batches
return grad_dict | python | def calc_expectation(grad_dict, num_batches):
"""Calculates the expectation of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients expectations
"""
for key in grad_dict.keys():
grad_dict[str.format(key+"_expectation")] = mx.ndarray.sum(grad_dict[key], axis=0) / num_batches
return grad_dict | [
"def",
"calc_expectation",
"(",
"grad_dict",
",",
"num_batches",
")",
":",
"for",
"key",
"in",
"grad_dict",
".",
"keys",
"(",
")",
":",
"grad_dict",
"[",
"str",
".",
"format",
"(",
"key",
"+",
"\"_expectation\"",
")",
"]",
"=",
"mx",
".",
"ndarray",
".",
"sum",
"(",
"grad_dict",
"[",
"key",
"]",
",",
"axis",
"=",
"0",
")",
"/",
"num_batches",
"return",
"grad_dict"
] | Calculates the expectation of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients expectations | [
"Calculates",
"the",
"expectation",
"of",
"the",
"gradients",
"per",
"epoch",
"for",
"each",
"parameter",
"w",
".",
"r",
".",
"t",
"number",
"of",
"batches"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/svrg_module/linear_regression/common.py#L74-L93 |
23,601 | apache/incubator-mxnet | example/svrg_module/linear_regression/common.py | calc_variance | def calc_variance(grad_dict, num_batches, param_names):
"""Calculates the variance of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
param_names: str
parameter name in the module
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients variance
"""
for i in range(len(param_names)):
diff_sqr = mx.ndarray.square(mx.nd.subtract(grad_dict[param_names[i]],
grad_dict[str.format(param_names[i]+"_expectation")]))
grad_dict[str.format(param_names[i] + "_variance")] = mx.ndarray.sum(diff_sqr, axis=0) / num_batches | python | def calc_variance(grad_dict, num_batches, param_names):
"""Calculates the variance of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
param_names: str
parameter name in the module
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients variance
"""
for i in range(len(param_names)):
diff_sqr = mx.ndarray.square(mx.nd.subtract(grad_dict[param_names[i]],
grad_dict[str.format(param_names[i]+"_expectation")]))
grad_dict[str.format(param_names[i] + "_variance")] = mx.ndarray.sum(diff_sqr, axis=0) / num_batches | [
"def",
"calc_variance",
"(",
"grad_dict",
",",
"num_batches",
",",
"param_names",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"param_names",
")",
")",
":",
"diff_sqr",
"=",
"mx",
".",
"ndarray",
".",
"square",
"(",
"mx",
".",
"nd",
".",
"subtract",
"(",
"grad_dict",
"[",
"param_names",
"[",
"i",
"]",
"]",
",",
"grad_dict",
"[",
"str",
".",
"format",
"(",
"param_names",
"[",
"i",
"]",
"+",
"\"_expectation\"",
")",
"]",
")",
")",
"grad_dict",
"[",
"str",
".",
"format",
"(",
"param_names",
"[",
"i",
"]",
"+",
"\"_variance\"",
")",
"]",
"=",
"mx",
".",
"ndarray",
".",
"sum",
"(",
"diff_sqr",
",",
"axis",
"=",
"0",
")",
"/",
"num_batches"
] | Calculates the variance of the gradients per epoch for each parameter w.r.t number of batches
Parameters
----------
grad_dict: dict
dictionary that maps parameter name to gradients in the mod executor group
num_batches: int
number of batches
param_names: str
parameter name in the module
Returns
----------
grad_dict: dict
dictionary with new keys mapping to gradients variance | [
"Calculates",
"the",
"variance",
"of",
"the",
"gradients",
"per",
"epoch",
"for",
"each",
"parameter",
"w",
".",
"r",
".",
"t",
"number",
"of",
"batches"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/svrg_module/linear_regression/common.py#L96-L117 |
23,602 | apache/incubator-mxnet | example/named_entity_recognition/src/metrics.py | classifer_metrics | def classifer_metrics(label, pred):
"""
computes f1, precision and recall on the entity class
"""
prediction = np.argmax(pred, axis=1)
label = label.astype(int)
pred_is_entity = prediction != not_entity_index
label_is_entity = label != not_entity_index
corr_pred = (prediction == label) == (pred_is_entity == True)
#how many entities are there?
num_entities = np.sum(label_is_entity)
entity_preds = np.sum(pred_is_entity)
#how many times did we correctly predict an entity?
correct_entitites = np.sum(corr_pred[pred_is_entity])
#precision: when we predict entity, how often are we right?
precision = correct_entitites/entity_preds
if entity_preds == 0:
precision = np.nan
#recall: of the things that were an entity, how many did we catch?
recall = correct_entitites / num_entities
if num_entities == 0:
recall = np.nan
f1 = 2 * precision * recall / (precision + recall)
return precision, recall, f1 | python | def classifer_metrics(label, pred):
"""
computes f1, precision and recall on the entity class
"""
prediction = np.argmax(pred, axis=1)
label = label.astype(int)
pred_is_entity = prediction != not_entity_index
label_is_entity = label != not_entity_index
corr_pred = (prediction == label) == (pred_is_entity == True)
#how many entities are there?
num_entities = np.sum(label_is_entity)
entity_preds = np.sum(pred_is_entity)
#how many times did we correctly predict an entity?
correct_entitites = np.sum(corr_pred[pred_is_entity])
#precision: when we predict entity, how often are we right?
precision = correct_entitites/entity_preds
if entity_preds == 0:
precision = np.nan
#recall: of the things that were an entity, how many did we catch?
recall = correct_entitites / num_entities
if num_entities == 0:
recall = np.nan
f1 = 2 * precision * recall / (precision + recall)
return precision, recall, f1 | [
"def",
"classifer_metrics",
"(",
"label",
",",
"pred",
")",
":",
"prediction",
"=",
"np",
".",
"argmax",
"(",
"pred",
",",
"axis",
"=",
"1",
")",
"label",
"=",
"label",
".",
"astype",
"(",
"int",
")",
"pred_is_entity",
"=",
"prediction",
"!=",
"not_entity_index",
"label_is_entity",
"=",
"label",
"!=",
"not_entity_index",
"corr_pred",
"=",
"(",
"prediction",
"==",
"label",
")",
"==",
"(",
"pred_is_entity",
"==",
"True",
")",
"#how many entities are there?",
"num_entities",
"=",
"np",
".",
"sum",
"(",
"label_is_entity",
")",
"entity_preds",
"=",
"np",
".",
"sum",
"(",
"pred_is_entity",
")",
"#how many times did we correctly predict an entity?",
"correct_entitites",
"=",
"np",
".",
"sum",
"(",
"corr_pred",
"[",
"pred_is_entity",
"]",
")",
"#precision: when we predict entity, how often are we right?",
"precision",
"=",
"correct_entitites",
"/",
"entity_preds",
"if",
"entity_preds",
"==",
"0",
":",
"precision",
"=",
"np",
".",
"nan",
"#recall: of the things that were an entity, how many did we catch?",
"recall",
"=",
"correct_entitites",
"/",
"num_entities",
"if",
"num_entities",
"==",
"0",
":",
"recall",
"=",
"np",
".",
"nan",
"f1",
"=",
"2",
"*",
"precision",
"*",
"recall",
"/",
"(",
"precision",
"+",
"recall",
")",
"return",
"precision",
",",
"recall",
",",
"f1"
] | computes f1, precision and recall on the entity class | [
"computes",
"f1",
"precision",
"and",
"recall",
"on",
"the",
"entity",
"class"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/named_entity_recognition/src/metrics.py#L33-L62 |
23,603 | apache/incubator-mxnet | example/cnn_text_classification/text_cnn.py | data_iter | def data_iter(batch_size, num_embed, pre_trained_word2vec=False):
"""Construct data iter
Parameters
----------
batch_size: int
num_embed: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
train_set: DataIter
Train DataIter
valid: DataIter
Valid DataIter
sentences_size: int
array dimensions
embedded_size: int
array dimensions
vocab_size: int
array dimensions
"""
print('Loading data...')
if pre_trained_word2vec:
word2vec = data_helpers.load_pretrained_word2vec('data/rt.vec')
x, y = data_helpers.load_data_with_word2vec(word2vec)
# reshape for convolution input
x = np.reshape(x, (x.shape[0], 1, x.shape[1], x.shape[2]))
embedded_size = x.shape[-1]
sentences_size = x.shape[2]
vocabulary_size = -1
else:
x, y, vocab, vocab_inv = data_helpers.load_data()
embedded_size = num_embed
sentences_size = x.shape[1]
vocabulary_size = len(vocab)
# randomly shuffle data
np.random.seed(10)
shuffle_indices = np.random.permutation(np.arange(len(y)))
x_shuffled = x[shuffle_indices]
y_shuffled = y[shuffle_indices]
# split train/valid set
x_train, x_dev = x_shuffled[:-1000], x_shuffled[-1000:]
y_train, y_dev = y_shuffled[:-1000], y_shuffled[-1000:]
print('Train/Valid split: %d/%d' % (len(y_train), len(y_dev)))
print('train shape:', x_train.shape)
print('valid shape:', x_dev.shape)
print('sentence max words', sentences_size)
print('embedding size', embedded_size)
print('vocab size', vocabulary_size)
train_set = mx.io.NDArrayIter(
x_train, y_train, batch_size, shuffle=True)
valid = mx.io.NDArrayIter(
x_dev, y_dev, batch_size)
return train_set, valid, sentences_size, embedded_size, vocabulary_size | python | def data_iter(batch_size, num_embed, pre_trained_word2vec=False):
"""Construct data iter
Parameters
----------
batch_size: int
num_embed: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
train_set: DataIter
Train DataIter
valid: DataIter
Valid DataIter
sentences_size: int
array dimensions
embedded_size: int
array dimensions
vocab_size: int
array dimensions
"""
print('Loading data...')
if pre_trained_word2vec:
word2vec = data_helpers.load_pretrained_word2vec('data/rt.vec')
x, y = data_helpers.load_data_with_word2vec(word2vec)
# reshape for convolution input
x = np.reshape(x, (x.shape[0], 1, x.shape[1], x.shape[2]))
embedded_size = x.shape[-1]
sentences_size = x.shape[2]
vocabulary_size = -1
else:
x, y, vocab, vocab_inv = data_helpers.load_data()
embedded_size = num_embed
sentences_size = x.shape[1]
vocabulary_size = len(vocab)
# randomly shuffle data
np.random.seed(10)
shuffle_indices = np.random.permutation(np.arange(len(y)))
x_shuffled = x[shuffle_indices]
y_shuffled = y[shuffle_indices]
# split train/valid set
x_train, x_dev = x_shuffled[:-1000], x_shuffled[-1000:]
y_train, y_dev = y_shuffled[:-1000], y_shuffled[-1000:]
print('Train/Valid split: %d/%d' % (len(y_train), len(y_dev)))
print('train shape:', x_train.shape)
print('valid shape:', x_dev.shape)
print('sentence max words', sentences_size)
print('embedding size', embedded_size)
print('vocab size', vocabulary_size)
train_set = mx.io.NDArrayIter(
x_train, y_train, batch_size, shuffle=True)
valid = mx.io.NDArrayIter(
x_dev, y_dev, batch_size)
return train_set, valid, sentences_size, embedded_size, vocabulary_size | [
"def",
"data_iter",
"(",
"batch_size",
",",
"num_embed",
",",
"pre_trained_word2vec",
"=",
"False",
")",
":",
"print",
"(",
"'Loading data...'",
")",
"if",
"pre_trained_word2vec",
":",
"word2vec",
"=",
"data_helpers",
".",
"load_pretrained_word2vec",
"(",
"'data/rt.vec'",
")",
"x",
",",
"y",
"=",
"data_helpers",
".",
"load_data_with_word2vec",
"(",
"word2vec",
")",
"# reshape for convolution input",
"x",
"=",
"np",
".",
"reshape",
"(",
"x",
",",
"(",
"x",
".",
"shape",
"[",
"0",
"]",
",",
"1",
",",
"x",
".",
"shape",
"[",
"1",
"]",
",",
"x",
".",
"shape",
"[",
"2",
"]",
")",
")",
"embedded_size",
"=",
"x",
".",
"shape",
"[",
"-",
"1",
"]",
"sentences_size",
"=",
"x",
".",
"shape",
"[",
"2",
"]",
"vocabulary_size",
"=",
"-",
"1",
"else",
":",
"x",
",",
"y",
",",
"vocab",
",",
"vocab_inv",
"=",
"data_helpers",
".",
"load_data",
"(",
")",
"embedded_size",
"=",
"num_embed",
"sentences_size",
"=",
"x",
".",
"shape",
"[",
"1",
"]",
"vocabulary_size",
"=",
"len",
"(",
"vocab",
")",
"# randomly shuffle data",
"np",
".",
"random",
".",
"seed",
"(",
"10",
")",
"shuffle_indices",
"=",
"np",
".",
"random",
".",
"permutation",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"y",
")",
")",
")",
"x_shuffled",
"=",
"x",
"[",
"shuffle_indices",
"]",
"y_shuffled",
"=",
"y",
"[",
"shuffle_indices",
"]",
"# split train/valid set",
"x_train",
",",
"x_dev",
"=",
"x_shuffled",
"[",
":",
"-",
"1000",
"]",
",",
"x_shuffled",
"[",
"-",
"1000",
":",
"]",
"y_train",
",",
"y_dev",
"=",
"y_shuffled",
"[",
":",
"-",
"1000",
"]",
",",
"y_shuffled",
"[",
"-",
"1000",
":",
"]",
"print",
"(",
"'Train/Valid split: %d/%d'",
"%",
"(",
"len",
"(",
"y_train",
")",
",",
"len",
"(",
"y_dev",
")",
")",
")",
"print",
"(",
"'train shape:'",
",",
"x_train",
".",
"shape",
")",
"print",
"(",
"'valid shape:'",
",",
"x_dev",
".",
"shape",
")",
"print",
"(",
"'sentence max words'",
",",
"sentences_size",
")",
"print",
"(",
"'embedding size'",
",",
"embedded_size",
")",
"print",
"(",
"'vocab size'",
",",
"vocabulary_size",
")",
"train_set",
"=",
"mx",
".",
"io",
".",
"NDArrayIter",
"(",
"x_train",
",",
"y_train",
",",
"batch_size",
",",
"shuffle",
"=",
"True",
")",
"valid",
"=",
"mx",
".",
"io",
".",
"NDArrayIter",
"(",
"x_dev",
",",
"y_dev",
",",
"batch_size",
")",
"return",
"train_set",
",",
"valid",
",",
"sentences_size",
",",
"embedded_size",
",",
"vocabulary_size"
] | Construct data iter
Parameters
----------
batch_size: int
num_embed: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
train_set: DataIter
Train DataIter
valid: DataIter
Valid DataIter
sentences_size: int
array dimensions
embedded_size: int
array dimensions
vocab_size: int
array dimensions | [
"Construct",
"data",
"iter"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_text_classification/text_cnn.py#L71-L129 |
23,604 | apache/incubator-mxnet | example/cnn_text_classification/text_cnn.py | sym_gen | def sym_gen(batch_size, sentences_size, num_embed, vocabulary_size,
num_label=2, filter_list=None, num_filter=100,
dropout=0.0, pre_trained_word2vec=False):
"""Generate network symbol
Parameters
----------
batch_size: int
sentences_size: int
num_embed: int
vocabulary_size: int
num_label: int
filter_list: list
num_filter: int
dropout: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
sm: symbol
data: list of str
data names
softmax_label: list of str
label names
"""
input_x = mx.sym.Variable('data')
input_y = mx.sym.Variable('softmax_label')
# embedding layer
if not pre_trained_word2vec:
embed_layer = mx.sym.Embedding(data=input_x,
input_dim=vocabulary_size,
output_dim=num_embed,
name='vocab_embed')
conv_input = mx.sym.Reshape(data=embed_layer, target_shape=(batch_size, 1, sentences_size, num_embed))
else:
conv_input = input_x
# create convolution + (max) pooling layer for each filter operation
pooled_outputs = []
for i, filter_size in enumerate(filter_list):
convi = mx.sym.Convolution(data=conv_input, kernel=(filter_size, num_embed), num_filter=num_filter)
relui = mx.sym.Activation(data=convi, act_type='relu')
pooli = mx.sym.Pooling(data=relui, pool_type='max', kernel=(sentences_size - filter_size + 1, 1), stride=(1, 1))
pooled_outputs.append(pooli)
# combine all pooled outputs
total_filters = num_filter * len(filter_list)
concat = mx.sym.Concat(*pooled_outputs, dim=1)
h_pool = mx.sym.Reshape(data=concat, target_shape=(batch_size, total_filters))
# dropout layer
if dropout > 0.0:
h_drop = mx.sym.Dropout(data=h_pool, p=dropout)
else:
h_drop = h_pool
# fully connected
cls_weight = mx.sym.Variable('cls_weight')
cls_bias = mx.sym.Variable('cls_bias')
fc = mx.sym.FullyConnected(data=h_drop, weight=cls_weight, bias=cls_bias, num_hidden=num_label)
# softmax output
sm = mx.sym.SoftmaxOutput(data=fc, label=input_y, name='softmax')
return sm, ('data',), ('softmax_label',) | python | def sym_gen(batch_size, sentences_size, num_embed, vocabulary_size,
num_label=2, filter_list=None, num_filter=100,
dropout=0.0, pre_trained_word2vec=False):
"""Generate network symbol
Parameters
----------
batch_size: int
sentences_size: int
num_embed: int
vocabulary_size: int
num_label: int
filter_list: list
num_filter: int
dropout: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
sm: symbol
data: list of str
data names
softmax_label: list of str
label names
"""
input_x = mx.sym.Variable('data')
input_y = mx.sym.Variable('softmax_label')
# embedding layer
if not pre_trained_word2vec:
embed_layer = mx.sym.Embedding(data=input_x,
input_dim=vocabulary_size,
output_dim=num_embed,
name='vocab_embed')
conv_input = mx.sym.Reshape(data=embed_layer, target_shape=(batch_size, 1, sentences_size, num_embed))
else:
conv_input = input_x
# create convolution + (max) pooling layer for each filter operation
pooled_outputs = []
for i, filter_size in enumerate(filter_list):
convi = mx.sym.Convolution(data=conv_input, kernel=(filter_size, num_embed), num_filter=num_filter)
relui = mx.sym.Activation(data=convi, act_type='relu')
pooli = mx.sym.Pooling(data=relui, pool_type='max', kernel=(sentences_size - filter_size + 1, 1), stride=(1, 1))
pooled_outputs.append(pooli)
# combine all pooled outputs
total_filters = num_filter * len(filter_list)
concat = mx.sym.Concat(*pooled_outputs, dim=1)
h_pool = mx.sym.Reshape(data=concat, target_shape=(batch_size, total_filters))
# dropout layer
if dropout > 0.0:
h_drop = mx.sym.Dropout(data=h_pool, p=dropout)
else:
h_drop = h_pool
# fully connected
cls_weight = mx.sym.Variable('cls_weight')
cls_bias = mx.sym.Variable('cls_bias')
fc = mx.sym.FullyConnected(data=h_drop, weight=cls_weight, bias=cls_bias, num_hidden=num_label)
# softmax output
sm = mx.sym.SoftmaxOutput(data=fc, label=input_y, name='softmax')
return sm, ('data',), ('softmax_label',) | [
"def",
"sym_gen",
"(",
"batch_size",
",",
"sentences_size",
",",
"num_embed",
",",
"vocabulary_size",
",",
"num_label",
"=",
"2",
",",
"filter_list",
"=",
"None",
",",
"num_filter",
"=",
"100",
",",
"dropout",
"=",
"0.0",
",",
"pre_trained_word2vec",
"=",
"False",
")",
":",
"input_x",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'data'",
")",
"input_y",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'softmax_label'",
")",
"# embedding layer",
"if",
"not",
"pre_trained_word2vec",
":",
"embed_layer",
"=",
"mx",
".",
"sym",
".",
"Embedding",
"(",
"data",
"=",
"input_x",
",",
"input_dim",
"=",
"vocabulary_size",
",",
"output_dim",
"=",
"num_embed",
",",
"name",
"=",
"'vocab_embed'",
")",
"conv_input",
"=",
"mx",
".",
"sym",
".",
"Reshape",
"(",
"data",
"=",
"embed_layer",
",",
"target_shape",
"=",
"(",
"batch_size",
",",
"1",
",",
"sentences_size",
",",
"num_embed",
")",
")",
"else",
":",
"conv_input",
"=",
"input_x",
"# create convolution + (max) pooling layer for each filter operation",
"pooled_outputs",
"=",
"[",
"]",
"for",
"i",
",",
"filter_size",
"in",
"enumerate",
"(",
"filter_list",
")",
":",
"convi",
"=",
"mx",
".",
"sym",
".",
"Convolution",
"(",
"data",
"=",
"conv_input",
",",
"kernel",
"=",
"(",
"filter_size",
",",
"num_embed",
")",
",",
"num_filter",
"=",
"num_filter",
")",
"relui",
"=",
"mx",
".",
"sym",
".",
"Activation",
"(",
"data",
"=",
"convi",
",",
"act_type",
"=",
"'relu'",
")",
"pooli",
"=",
"mx",
".",
"sym",
".",
"Pooling",
"(",
"data",
"=",
"relui",
",",
"pool_type",
"=",
"'max'",
",",
"kernel",
"=",
"(",
"sentences_size",
"-",
"filter_size",
"+",
"1",
",",
"1",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
")",
"pooled_outputs",
".",
"append",
"(",
"pooli",
")",
"# combine all pooled outputs",
"total_filters",
"=",
"num_filter",
"*",
"len",
"(",
"filter_list",
")",
"concat",
"=",
"mx",
".",
"sym",
".",
"Concat",
"(",
"*",
"pooled_outputs",
",",
"dim",
"=",
"1",
")",
"h_pool",
"=",
"mx",
".",
"sym",
".",
"Reshape",
"(",
"data",
"=",
"concat",
",",
"target_shape",
"=",
"(",
"batch_size",
",",
"total_filters",
")",
")",
"# dropout layer",
"if",
"dropout",
">",
"0.0",
":",
"h_drop",
"=",
"mx",
".",
"sym",
".",
"Dropout",
"(",
"data",
"=",
"h_pool",
",",
"p",
"=",
"dropout",
")",
"else",
":",
"h_drop",
"=",
"h_pool",
"# fully connected",
"cls_weight",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'cls_weight'",
")",
"cls_bias",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"'cls_bias'",
")",
"fc",
"=",
"mx",
".",
"sym",
".",
"FullyConnected",
"(",
"data",
"=",
"h_drop",
",",
"weight",
"=",
"cls_weight",
",",
"bias",
"=",
"cls_bias",
",",
"num_hidden",
"=",
"num_label",
")",
"# softmax output",
"sm",
"=",
"mx",
".",
"sym",
".",
"SoftmaxOutput",
"(",
"data",
"=",
"fc",
",",
"label",
"=",
"input_y",
",",
"name",
"=",
"'softmax'",
")",
"return",
"sm",
",",
"(",
"'data'",
",",
")",
",",
"(",
"'softmax_label'",
",",
")"
] | Generate network symbol
Parameters
----------
batch_size: int
sentences_size: int
num_embed: int
vocabulary_size: int
num_label: int
filter_list: list
num_filter: int
dropout: int
pre_trained_word2vec: boolean
identify the pre-trained layers or not
Returns
----------
sm: symbol
data: list of str
data names
softmax_label: list of str
label names | [
"Generate",
"network",
"symbol"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_text_classification/text_cnn.py#L132-L198 |
23,605 | apache/incubator-mxnet | example/cnn_text_classification/text_cnn.py | train | def train(symbol_data, train_iterator, valid_iterator, data_column_names, target_names):
"""Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification
"""
devs = mx.cpu() # default setting
if args.gpus is not None:
for i in args.gpus.split(','):
mx.gpu(int(i))
devs = mx.gpu()
module = mx.mod.Module(symbol_data, data_names=data_column_names, label_names=target_names, context=devs)
module.fit(train_data=train_iterator,
eval_data=valid_iterator,
eval_metric='acc',
kvstore=args.kv_store,
optimizer=args.optimizer,
optimizer_params={'learning_rate': args.lr},
initializer=mx.initializer.Uniform(0.1),
num_epoch=args.num_epochs,
batch_end_callback=mx.callback.Speedometer(args.batch_size, args.disp_batches),
epoch_end_callback=save_model()) | python | def train(symbol_data, train_iterator, valid_iterator, data_column_names, target_names):
"""Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification
"""
devs = mx.cpu() # default setting
if args.gpus is not None:
for i in args.gpus.split(','):
mx.gpu(int(i))
devs = mx.gpu()
module = mx.mod.Module(symbol_data, data_names=data_column_names, label_names=target_names, context=devs)
module.fit(train_data=train_iterator,
eval_data=valid_iterator,
eval_metric='acc',
kvstore=args.kv_store,
optimizer=args.optimizer,
optimizer_params={'learning_rate': args.lr},
initializer=mx.initializer.Uniform(0.1),
num_epoch=args.num_epochs,
batch_end_callback=mx.callback.Speedometer(args.batch_size, args.disp_batches),
epoch_end_callback=save_model()) | [
"def",
"train",
"(",
"symbol_data",
",",
"train_iterator",
",",
"valid_iterator",
",",
"data_column_names",
",",
"target_names",
")",
":",
"devs",
"=",
"mx",
".",
"cpu",
"(",
")",
"# default setting",
"if",
"args",
".",
"gpus",
"is",
"not",
"None",
":",
"for",
"i",
"in",
"args",
".",
"gpus",
".",
"split",
"(",
"','",
")",
":",
"mx",
".",
"gpu",
"(",
"int",
"(",
"i",
")",
")",
"devs",
"=",
"mx",
".",
"gpu",
"(",
")",
"module",
"=",
"mx",
".",
"mod",
".",
"Module",
"(",
"symbol_data",
",",
"data_names",
"=",
"data_column_names",
",",
"label_names",
"=",
"target_names",
",",
"context",
"=",
"devs",
")",
"module",
".",
"fit",
"(",
"train_data",
"=",
"train_iterator",
",",
"eval_data",
"=",
"valid_iterator",
",",
"eval_metric",
"=",
"'acc'",
",",
"kvstore",
"=",
"args",
".",
"kv_store",
",",
"optimizer",
"=",
"args",
".",
"optimizer",
",",
"optimizer_params",
"=",
"{",
"'learning_rate'",
":",
"args",
".",
"lr",
"}",
",",
"initializer",
"=",
"mx",
".",
"initializer",
".",
"Uniform",
"(",
"0.1",
")",
",",
"num_epoch",
"=",
"args",
".",
"num_epochs",
",",
"batch_end_callback",
"=",
"mx",
".",
"callback",
".",
"Speedometer",
"(",
"args",
".",
"batch_size",
",",
"args",
".",
"disp_batches",
")",
",",
"epoch_end_callback",
"=",
"save_model",
"(",
")",
")"
] | Train cnn model
Parameters
----------
symbol_data: symbol
train_iterator: DataIter
Train DataIter
valid_iterator: DataIter
Valid DataIter
data_column_names: list of str
Defaults to ('data') for a typical model used in image classification
target_names: list of str
Defaults to ('softmax_label') for a typical model used in image classification | [
"Train",
"cnn",
"model"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/cnn_text_classification/text_cnn.py#L201-L231 |
23,606 | apache/incubator-mxnet | dev_menu.py | build | def build(args) -> None:
"""Build using CMake"""
venv_exe = shutil.which('virtualenv')
pyexe = shutil.which(args.pyexe)
if not venv_exe:
logging.warn("virtualenv wasn't found in path, it's recommended to install virtualenv to manage python environments")
if not pyexe:
logging.warn("Python executable %s not found in path", args.pyexe)
if args.cmake_options:
cmake = CMake(args.cmake_options)
else:
cmake = CMake()
cmake()
create_virtualenv(venv_exe, pyexe, args.venv) | python | def build(args) -> None:
"""Build using CMake"""
venv_exe = shutil.which('virtualenv')
pyexe = shutil.which(args.pyexe)
if not venv_exe:
logging.warn("virtualenv wasn't found in path, it's recommended to install virtualenv to manage python environments")
if not pyexe:
logging.warn("Python executable %s not found in path", args.pyexe)
if args.cmake_options:
cmake = CMake(args.cmake_options)
else:
cmake = CMake()
cmake()
create_virtualenv(venv_exe, pyexe, args.venv) | [
"def",
"build",
"(",
"args",
")",
"->",
"None",
":",
"venv_exe",
"=",
"shutil",
".",
"which",
"(",
"'virtualenv'",
")",
"pyexe",
"=",
"shutil",
".",
"which",
"(",
"args",
".",
"pyexe",
")",
"if",
"not",
"venv_exe",
":",
"logging",
".",
"warn",
"(",
"\"virtualenv wasn't found in path, it's recommended to install virtualenv to manage python environments\"",
")",
"if",
"not",
"pyexe",
":",
"logging",
".",
"warn",
"(",
"\"Python executable %s not found in path\"",
",",
"args",
".",
"pyexe",
")",
"if",
"args",
".",
"cmake_options",
":",
"cmake",
"=",
"CMake",
"(",
"args",
".",
"cmake_options",
")",
"else",
":",
"cmake",
"=",
"CMake",
"(",
")",
"cmake",
"(",
")",
"create_virtualenv",
"(",
"venv_exe",
",",
"pyexe",
",",
"args",
".",
"venv",
")"
] | Build using CMake | [
"Build",
"using",
"CMake"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/dev_menu.py#L199-L212 |
23,607 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | parse_helper | def parse_helper(attrs, attrs_name, alt_value=None):
"""Helper function to parse operator attributes in required format."""
tuple_re = re.compile('\([0-9L|,| ]+\)')
if not attrs:
return alt_value
attrs_str = None if attrs.get(attrs_name) is None else str(attrs.get(attrs_name))
if attrs_str is None:
return alt_value
attrs_match = tuple_re.search(attrs_str)
if attrs_match is not None:
if attrs_match.span() == (0, len(attrs_str)):
dims = eval(attrs_str)
return dims
else:
raise AttributeError("Malformed %s dimensions: %s" % (attrs_name, str(attrs_str)))
return alt_value | python | def parse_helper(attrs, attrs_name, alt_value=None):
"""Helper function to parse operator attributes in required format."""
tuple_re = re.compile('\([0-9L|,| ]+\)')
if not attrs:
return alt_value
attrs_str = None if attrs.get(attrs_name) is None else str(attrs.get(attrs_name))
if attrs_str is None:
return alt_value
attrs_match = tuple_re.search(attrs_str)
if attrs_match is not None:
if attrs_match.span() == (0, len(attrs_str)):
dims = eval(attrs_str)
return dims
else:
raise AttributeError("Malformed %s dimensions: %s" % (attrs_name, str(attrs_str)))
return alt_value | [
"def",
"parse_helper",
"(",
"attrs",
",",
"attrs_name",
",",
"alt_value",
"=",
"None",
")",
":",
"tuple_re",
"=",
"re",
".",
"compile",
"(",
"'\\([0-9L|,| ]+\\)'",
")",
"if",
"not",
"attrs",
":",
"return",
"alt_value",
"attrs_str",
"=",
"None",
"if",
"attrs",
".",
"get",
"(",
"attrs_name",
")",
"is",
"None",
"else",
"str",
"(",
"attrs",
".",
"get",
"(",
"attrs_name",
")",
")",
"if",
"attrs_str",
"is",
"None",
":",
"return",
"alt_value",
"attrs_match",
"=",
"tuple_re",
".",
"search",
"(",
"attrs_str",
")",
"if",
"attrs_match",
"is",
"not",
"None",
":",
"if",
"attrs_match",
".",
"span",
"(",
")",
"==",
"(",
"0",
",",
"len",
"(",
"attrs_str",
")",
")",
":",
"dims",
"=",
"eval",
"(",
"attrs_str",
")",
"return",
"dims",
"else",
":",
"raise",
"AttributeError",
"(",
"\"Malformed %s dimensions: %s\"",
"%",
"(",
"attrs_name",
",",
"str",
"(",
"attrs_str",
")",
")",
")",
"return",
"alt_value"
] | Helper function to parse operator attributes in required format. | [
"Helper",
"function",
"to",
"parse",
"operator",
"attributes",
"in",
"required",
"format",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L69-L84 |
23,608 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | transform_padding | def transform_padding(pad_width):
"""Helper function to convert padding format for pad operator.
"""
num_pad_values = len(pad_width)
onnx_pad_width = [0]*num_pad_values
start_index = 0
# num_pad_values will always be multiple of 2
end_index = int(num_pad_values/2)
for idx in range(0, num_pad_values):
if idx % 2 == 0:
onnx_pad_width[start_index] = pad_width[idx]
start_index += 1
else:
onnx_pad_width[end_index] = pad_width[idx]
end_index += 1
return onnx_pad_width | python | def transform_padding(pad_width):
"""Helper function to convert padding format for pad operator.
"""
num_pad_values = len(pad_width)
onnx_pad_width = [0]*num_pad_values
start_index = 0
# num_pad_values will always be multiple of 2
end_index = int(num_pad_values/2)
for idx in range(0, num_pad_values):
if idx % 2 == 0:
onnx_pad_width[start_index] = pad_width[idx]
start_index += 1
else:
onnx_pad_width[end_index] = pad_width[idx]
end_index += 1
return onnx_pad_width | [
"def",
"transform_padding",
"(",
"pad_width",
")",
":",
"num_pad_values",
"=",
"len",
"(",
"pad_width",
")",
"onnx_pad_width",
"=",
"[",
"0",
"]",
"*",
"num_pad_values",
"start_index",
"=",
"0",
"# num_pad_values will always be multiple of 2",
"end_index",
"=",
"int",
"(",
"num_pad_values",
"/",
"2",
")",
"for",
"idx",
"in",
"range",
"(",
"0",
",",
"num_pad_values",
")",
":",
"if",
"idx",
"%",
"2",
"==",
"0",
":",
"onnx_pad_width",
"[",
"start_index",
"]",
"=",
"pad_width",
"[",
"idx",
"]",
"start_index",
"+=",
"1",
"else",
":",
"onnx_pad_width",
"[",
"end_index",
"]",
"=",
"pad_width",
"[",
"idx",
"]",
"end_index",
"+=",
"1",
"return",
"onnx_pad_width"
] | Helper function to convert padding format for pad operator. | [
"Helper",
"function",
"to",
"convert",
"padding",
"format",
"for",
"pad",
"operator",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L86-L103 |
23,609 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_string_to_list | def convert_string_to_list(string_val):
"""Helper function to convert string to list.
Used to convert shape attribute string to list format.
"""
result_list = []
list_string = string_val.split(',')
for val in list_string:
val = str(val.strip())
val = val.replace("(", "")
val = val.replace(")", "")
val = val.replace("L", "")
val = val.replace("[", "")
val = val.replace("]", "")
if val not in ("", "None"):
result_list.append(int(val))
return result_list | python | def convert_string_to_list(string_val):
"""Helper function to convert string to list.
Used to convert shape attribute string to list format.
"""
result_list = []
list_string = string_val.split(',')
for val in list_string:
val = str(val.strip())
val = val.replace("(", "")
val = val.replace(")", "")
val = val.replace("L", "")
val = val.replace("[", "")
val = val.replace("]", "")
if val not in ("", "None"):
result_list.append(int(val))
return result_list | [
"def",
"convert_string_to_list",
"(",
"string_val",
")",
":",
"result_list",
"=",
"[",
"]",
"list_string",
"=",
"string_val",
".",
"split",
"(",
"','",
")",
"for",
"val",
"in",
"list_string",
":",
"val",
"=",
"str",
"(",
"val",
".",
"strip",
"(",
")",
")",
"val",
"=",
"val",
".",
"replace",
"(",
"\"(\"",
",",
"\"\"",
")",
"val",
"=",
"val",
".",
"replace",
"(",
"\")\"",
",",
"\"\"",
")",
"val",
"=",
"val",
".",
"replace",
"(",
"\"L\"",
",",
"\"\"",
")",
"val",
"=",
"val",
".",
"replace",
"(",
"\"[\"",
",",
"\"\"",
")",
"val",
"=",
"val",
".",
"replace",
"(",
"\"]\"",
",",
"\"\"",
")",
"if",
"val",
"not",
"in",
"(",
"\"\"",
",",
"\"None\"",
")",
":",
"result_list",
".",
"append",
"(",
"int",
"(",
"val",
")",
")",
"return",
"result_list"
] | Helper function to convert string to list.
Used to convert shape attribute string to list format. | [
"Helper",
"function",
"to",
"convert",
"string",
"to",
"list",
".",
"Used",
"to",
"convert",
"shape",
"attribute",
"string",
"to",
"list",
"format",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L106-L123 |
23,610 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | get_inputs | def get_inputs(node, kwargs):
"""Helper function to get inputs"""
name = node["name"]
proc_nodes = kwargs["proc_nodes"]
index_lookup = kwargs["index_lookup"]
inputs = node["inputs"]
attrs = node.get("attrs", {})
input_nodes = []
for ip in inputs:
input_node_id = index_lookup[ip[0]]
input_nodes.append(proc_nodes[input_node_id].name)
return name, input_nodes, attrs | python | def get_inputs(node, kwargs):
"""Helper function to get inputs"""
name = node["name"]
proc_nodes = kwargs["proc_nodes"]
index_lookup = kwargs["index_lookup"]
inputs = node["inputs"]
attrs = node.get("attrs", {})
input_nodes = []
for ip in inputs:
input_node_id = index_lookup[ip[0]]
input_nodes.append(proc_nodes[input_node_id].name)
return name, input_nodes, attrs | [
"def",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
":",
"name",
"=",
"node",
"[",
"\"name\"",
"]",
"proc_nodes",
"=",
"kwargs",
"[",
"\"proc_nodes\"",
"]",
"index_lookup",
"=",
"kwargs",
"[",
"\"index_lookup\"",
"]",
"inputs",
"=",
"node",
"[",
"\"inputs\"",
"]",
"attrs",
"=",
"node",
".",
"get",
"(",
"\"attrs\"",
",",
"{",
"}",
")",
"input_nodes",
"=",
"[",
"]",
"for",
"ip",
"in",
"inputs",
":",
"input_node_id",
"=",
"index_lookup",
"[",
"ip",
"[",
"0",
"]",
"]",
"input_nodes",
".",
"append",
"(",
"proc_nodes",
"[",
"input_node_id",
"]",
".",
"name",
")",
"return",
"name",
",",
"input_nodes",
",",
"attrs"
] | Helper function to get inputs | [
"Helper",
"function",
"to",
"get",
"inputs"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L133-L146 |
23,611 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | create_basic_op_node | def create_basic_op_node(op_name, node, kwargs):
"""Helper function to create a basic operator
node that doesn't contain op specific attrs"""
name, input_nodes, _ = get_inputs(node, kwargs)
node = onnx.helper.make_node(
op_name,
input_nodes,
[name],
name=name
)
return [node] | python | def create_basic_op_node(op_name, node, kwargs):
"""Helper function to create a basic operator
node that doesn't contain op specific attrs"""
name, input_nodes, _ = get_inputs(node, kwargs)
node = onnx.helper.make_node(
op_name,
input_nodes,
[name],
name=name
)
return [node] | [
"def",
"create_basic_op_node",
"(",
"op_name",
",",
"node",
",",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"_",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"op_name",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Helper function to create a basic operator
node that doesn't contain op specific attrs | [
"Helper",
"function",
"to",
"create",
"a",
"basic",
"operator",
"node",
"that",
"doesn",
"t",
"contain",
"op",
"specific",
"attrs"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L148-L159 |
23,612 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_weights_and_inputs | def convert_weights_and_inputs(node, **kwargs):
"""Helper function to convert weights and inputs.
"""
name, _, _ = get_inputs(node, kwargs)
if kwargs["is_input"] is False:
weights = kwargs["weights"]
initializer = kwargs["initializer"]
np_arr = weights[name]
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np_arr.dtype]
dims = np.shape(np_arr)
tensor_node = onnx.helper.make_tensor_value_info(name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=name,
data_type=data_type,
dims=dims,
vals=np_arr.flatten().tolist(),
raw=False,
)
)
return [tensor_node]
else:
tval_node = onnx.helper.make_tensor_value_info(name, kwargs["in_type"], kwargs["in_shape"])
return [tval_node] | python | def convert_weights_and_inputs(node, **kwargs):
"""Helper function to convert weights and inputs.
"""
name, _, _ = get_inputs(node, kwargs)
if kwargs["is_input"] is False:
weights = kwargs["weights"]
initializer = kwargs["initializer"]
np_arr = weights[name]
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np_arr.dtype]
dims = np.shape(np_arr)
tensor_node = onnx.helper.make_tensor_value_info(name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=name,
data_type=data_type,
dims=dims,
vals=np_arr.flatten().tolist(),
raw=False,
)
)
return [tensor_node]
else:
tval_node = onnx.helper.make_tensor_value_info(name, kwargs["in_type"], kwargs["in_shape"])
return [tval_node] | [
"def",
"convert_weights_and_inputs",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"_",
",",
"_",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"if",
"kwargs",
"[",
"\"is_input\"",
"]",
"is",
"False",
":",
"weights",
"=",
"kwargs",
"[",
"\"weights\"",
"]",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"np_arr",
"=",
"weights",
"[",
"name",
"]",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np_arr",
".",
"dtype",
"]",
"dims",
"=",
"np",
".",
"shape",
"(",
"np_arr",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"name",
",",
"data_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"np_arr",
".",
"flatten",
"(",
")",
".",
"tolist",
"(",
")",
",",
"raw",
"=",
"False",
",",
")",
")",
"return",
"[",
"tensor_node",
"]",
"else",
":",
"tval_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"name",
",",
"kwargs",
"[",
"\"in_type\"",
"]",
",",
"kwargs",
"[",
"\"in_shape\"",
"]",
")",
"return",
"[",
"tval_node",
"]"
] | Helper function to convert weights and inputs. | [
"Helper",
"function",
"to",
"convert",
"weights",
"and",
"inputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L162-L189 |
23,613 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_convolution | def convert_convolution(node, **kwargs):
"""Map MXNet's convolution operator attributes to onnx's Conv operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
kernel_dims = list(parse_helper(attrs, "kernel"))
stride_dims = list(parse_helper(attrs, "stride", [1, 1]))
pad_dims = list(parse_helper(attrs, "pad", [0, 0]))
num_group = int(attrs.get("num_group", 1))
dilations = list(parse_helper(attrs, "dilate", [1, 1]))
pad_dims = pad_dims + pad_dims
conv_node = onnx.helper.make_node(
"Conv",
inputs=input_nodes,
outputs=[name],
kernel_shape=kernel_dims,
strides=stride_dims,
dilations=dilations,
pads=pad_dims,
group=num_group,
name=name
)
return [conv_node] | python | def convert_convolution(node, **kwargs):
"""Map MXNet's convolution operator attributes to onnx's Conv operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
kernel_dims = list(parse_helper(attrs, "kernel"))
stride_dims = list(parse_helper(attrs, "stride", [1, 1]))
pad_dims = list(parse_helper(attrs, "pad", [0, 0]))
num_group = int(attrs.get("num_group", 1))
dilations = list(parse_helper(attrs, "dilate", [1, 1]))
pad_dims = pad_dims + pad_dims
conv_node = onnx.helper.make_node(
"Conv",
inputs=input_nodes,
outputs=[name],
kernel_shape=kernel_dims,
strides=stride_dims,
dilations=dilations,
pads=pad_dims,
group=num_group,
name=name
)
return [conv_node] | [
"def",
"convert_convolution",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"kernel_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"kernel\"",
")",
")",
"stride_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"stride\"",
",",
"[",
"1",
",",
"1",
"]",
")",
")",
"pad_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"pad\"",
",",
"[",
"0",
",",
"0",
"]",
")",
")",
"num_group",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"num_group\"",
",",
"1",
")",
")",
"dilations",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"dilate\"",
",",
"[",
"1",
",",
"1",
"]",
")",
")",
"pad_dims",
"=",
"pad_dims",
"+",
"pad_dims",
"conv_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Conv\"",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"kernel_shape",
"=",
"kernel_dims",
",",
"strides",
"=",
"stride_dims",
",",
"dilations",
"=",
"dilations",
",",
"pads",
"=",
"pad_dims",
",",
"group",
"=",
"num_group",
",",
"name",
"=",
"name",
")",
"return",
"[",
"conv_node",
"]"
] | Map MXNet's convolution operator attributes to onnx's Conv operator
and return the created node. | [
"Map",
"MXNet",
"s",
"convolution",
"operator",
"attributes",
"to",
"onnx",
"s",
"Conv",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L193-L219 |
23,614 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_deconvolution | def convert_deconvolution(node, **kwargs):
"""Map MXNet's deconvolution operator attributes to onnx's ConvTranspose operator
and return the created node.
"""
name, inputs, attrs = get_inputs(node, kwargs)
kernel_dims = list(parse_helper(attrs, "kernel"))
stride_dims = list(parse_helper(attrs, "stride", [1, 1]))
pad_dims = list(parse_helper(attrs, "pad", [0, 0]))
num_group = int(attrs.get("num_group", 1))
dilations = list(parse_helper(attrs, "dilate", [1, 1]))
adj_dims = list(parse_helper(attrs, "adj", [0, 0]))
pad_dims = pad_dims + pad_dims
deconv_node = onnx.helper.make_node(
"ConvTranspose",
inputs=inputs,
outputs=[name],
kernel_shape=kernel_dims,
strides=stride_dims,
dilations=dilations,
output_padding=adj_dims,
pads=pad_dims,
group=num_group,
name=name
)
return [deconv_node] | python | def convert_deconvolution(node, **kwargs):
"""Map MXNet's deconvolution operator attributes to onnx's ConvTranspose operator
and return the created node.
"""
name, inputs, attrs = get_inputs(node, kwargs)
kernel_dims = list(parse_helper(attrs, "kernel"))
stride_dims = list(parse_helper(attrs, "stride", [1, 1]))
pad_dims = list(parse_helper(attrs, "pad", [0, 0]))
num_group = int(attrs.get("num_group", 1))
dilations = list(parse_helper(attrs, "dilate", [1, 1]))
adj_dims = list(parse_helper(attrs, "adj", [0, 0]))
pad_dims = pad_dims + pad_dims
deconv_node = onnx.helper.make_node(
"ConvTranspose",
inputs=inputs,
outputs=[name],
kernel_shape=kernel_dims,
strides=stride_dims,
dilations=dilations,
output_padding=adj_dims,
pads=pad_dims,
group=num_group,
name=name
)
return [deconv_node] | [
"def",
"convert_deconvolution",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"inputs",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"kernel_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"kernel\"",
")",
")",
"stride_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"stride\"",
",",
"[",
"1",
",",
"1",
"]",
")",
")",
"pad_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"pad\"",
",",
"[",
"0",
",",
"0",
"]",
")",
")",
"num_group",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"num_group\"",
",",
"1",
")",
")",
"dilations",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"dilate\"",
",",
"[",
"1",
",",
"1",
"]",
")",
")",
"adj_dims",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"adj\"",
",",
"[",
"0",
",",
"0",
"]",
")",
")",
"pad_dims",
"=",
"pad_dims",
"+",
"pad_dims",
"deconv_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"ConvTranspose\"",
",",
"inputs",
"=",
"inputs",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"kernel_shape",
"=",
"kernel_dims",
",",
"strides",
"=",
"stride_dims",
",",
"dilations",
"=",
"dilations",
",",
"output_padding",
"=",
"adj_dims",
",",
"pads",
"=",
"pad_dims",
",",
"group",
"=",
"num_group",
",",
"name",
"=",
"name",
")",
"return",
"[",
"deconv_node",
"]"
] | Map MXNet's deconvolution operator attributes to onnx's ConvTranspose operator
and return the created node. | [
"Map",
"MXNet",
"s",
"deconvolution",
"operator",
"attributes",
"to",
"onnx",
"s",
"ConvTranspose",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L223-L251 |
23,615 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_crop | def convert_crop(node, **kwargs):
"""Map MXNet's crop operator attributes to onnx's Crop operator
and return the created node.
"""
name, inputs, attrs = get_inputs(node, kwargs)
num_inputs = len(inputs)
y, x = list(parse_helper(attrs, "offset", [0, 0]))
h, w = list(parse_helper(attrs, "h_w", [0, 0]))
if num_inputs > 1:
h, w = kwargs["out_shape"][-2:]
border = [x, y, x + w, y + h]
crop_node = onnx.helper.make_node(
"Crop",
inputs=[inputs[0]],
outputs=[name],
border=border,
scale=[1, 1],
name=name
)
logging.warning(
"Using an experimental ONNX operator: Crop. " \
"Its definition can change.")
return [crop_node] | python | def convert_crop(node, **kwargs):
"""Map MXNet's crop operator attributes to onnx's Crop operator
and return the created node.
"""
name, inputs, attrs = get_inputs(node, kwargs)
num_inputs = len(inputs)
y, x = list(parse_helper(attrs, "offset", [0, 0]))
h, w = list(parse_helper(attrs, "h_w", [0, 0]))
if num_inputs > 1:
h, w = kwargs["out_shape"][-2:]
border = [x, y, x + w, y + h]
crop_node = onnx.helper.make_node(
"Crop",
inputs=[inputs[0]],
outputs=[name],
border=border,
scale=[1, 1],
name=name
)
logging.warning(
"Using an experimental ONNX operator: Crop. " \
"Its definition can change.")
return [crop_node] | [
"def",
"convert_crop",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"inputs",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"num_inputs",
"=",
"len",
"(",
"inputs",
")",
"y",
",",
"x",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"offset\"",
",",
"[",
"0",
",",
"0",
"]",
")",
")",
"h",
",",
"w",
"=",
"list",
"(",
"parse_helper",
"(",
"attrs",
",",
"\"h_w\"",
",",
"[",
"0",
",",
"0",
"]",
")",
")",
"if",
"num_inputs",
">",
"1",
":",
"h",
",",
"w",
"=",
"kwargs",
"[",
"\"out_shape\"",
"]",
"[",
"-",
"2",
":",
"]",
"border",
"=",
"[",
"x",
",",
"y",
",",
"x",
"+",
"w",
",",
"y",
"+",
"h",
"]",
"crop_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Crop\"",
",",
"inputs",
"=",
"[",
"inputs",
"[",
"0",
"]",
"]",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"border",
"=",
"border",
",",
"scale",
"=",
"[",
"1",
",",
"1",
"]",
",",
"name",
"=",
"name",
")",
"logging",
".",
"warning",
"(",
"\"Using an experimental ONNX operator: Crop. \"",
"\"Its definition can change.\"",
")",
"return",
"[",
"crop_node",
"]"
] | Map MXNet's crop operator attributes to onnx's Crop operator
and return the created node. | [
"Map",
"MXNet",
"s",
"crop",
"operator",
"attributes",
"to",
"onnx",
"s",
"Crop",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L255-L281 |
23,616 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_fully_connected | def convert_fully_connected(node, **kwargs):
"""Map MXNet's FullyConnected operator attributes to onnx's Gemm operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
no_bias = get_boolean_attribute_value(attrs, "no_bias")
fcnode = []
op_name = "flatten_" + str(kwargs["idx"])
flatten_node = onnx.helper.make_node(
'Flatten',
inputs=[input_nodes[0]],
outputs=[op_name],
name=op_name
)
input_nodes[0] = op_name
fcnode.append(flatten_node)
if no_bias:
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]
bias_name = "bias" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(bias_name, data_type, (1,))
initializer.append(
onnx.helper.make_tensor(
name=bias_name,
data_type=data_type,
dims=(1,),
vals=[0],
raw=False,
)
)
input_nodes.append(bias_name)
fcnode.append(tensor_node)
node = onnx.helper.make_node(
"Gemm",
input_nodes, # input (A, B, C) - C can be in place
[name], # output
alpha=1.0,
beta=1.0,
transA=False,
transB=True,
name=name
)
fcnode.append(node)
return fcnode | python | def convert_fully_connected(node, **kwargs):
"""Map MXNet's FullyConnected operator attributes to onnx's Gemm operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
no_bias = get_boolean_attribute_value(attrs, "no_bias")
fcnode = []
op_name = "flatten_" + str(kwargs["idx"])
flatten_node = onnx.helper.make_node(
'Flatten',
inputs=[input_nodes[0]],
outputs=[op_name],
name=op_name
)
input_nodes[0] = op_name
fcnode.append(flatten_node)
if no_bias:
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]
bias_name = "bias" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(bias_name, data_type, (1,))
initializer.append(
onnx.helper.make_tensor(
name=bias_name,
data_type=data_type,
dims=(1,),
vals=[0],
raw=False,
)
)
input_nodes.append(bias_name)
fcnode.append(tensor_node)
node = onnx.helper.make_node(
"Gemm",
input_nodes, # input (A, B, C) - C can be in place
[name], # output
alpha=1.0,
beta=1.0,
transA=False,
transB=True,
name=name
)
fcnode.append(node)
return fcnode | [
"def",
"convert_fully_connected",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"no_bias",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"no_bias\"",
")",
"fcnode",
"=",
"[",
"]",
"op_name",
"=",
"\"flatten_\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"flatten_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Flatten'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"0",
"]",
"]",
",",
"outputs",
"=",
"[",
"op_name",
"]",
",",
"name",
"=",
"op_name",
")",
"input_nodes",
"[",
"0",
"]",
"=",
"op_name",
"fcnode",
".",
"append",
"(",
"flatten_node",
")",
"if",
"no_bias",
":",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np",
".",
"dtype",
"(",
"'int64'",
")",
"]",
"bias_name",
"=",
"\"bias\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"bias_name",
",",
"data_type",
",",
"(",
"1",
",",
")",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"bias_name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"(",
"1",
",",
")",
",",
"vals",
"=",
"[",
"0",
"]",
",",
"raw",
"=",
"False",
",",
")",
")",
"input_nodes",
".",
"append",
"(",
"bias_name",
")",
"fcnode",
".",
"append",
"(",
"tensor_node",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Gemm\"",
",",
"input_nodes",
",",
"# input (A, B, C) - C can be in place",
"[",
"name",
"]",
",",
"# output",
"alpha",
"=",
"1.0",
",",
"beta",
"=",
"1.0",
",",
"transA",
"=",
"False",
",",
"transB",
"=",
"True",
",",
"name",
"=",
"name",
")",
"fcnode",
".",
"append",
"(",
"node",
")",
"return",
"fcnode"
] | Map MXNet's FullyConnected operator attributes to onnx's Gemm operator
and return the created node. | [
"Map",
"MXNet",
"s",
"FullyConnected",
"operator",
"attributes",
"to",
"onnx",
"s",
"Gemm",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L285-L337 |
23,617 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_batchnorm | def convert_batchnorm(node, **kwargs):
"""Map MXNet's BatchNorm operator attributes to onnx's BatchNormalization operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
momentum = float(attrs.get("momentum", 0.9))
eps = float(attrs.get("eps", 0.001))
bn_node = onnx.helper.make_node(
"BatchNormalization",
input_nodes,
[name],
name=name,
epsilon=eps,
momentum=momentum,
# MXNet computes mean and variance per feature for batchnorm
# Default for onnx is across all spatial features. So disabling the parameter.
spatial=0
)
return [bn_node] | python | def convert_batchnorm(node, **kwargs):
"""Map MXNet's BatchNorm operator attributes to onnx's BatchNormalization operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
momentum = float(attrs.get("momentum", 0.9))
eps = float(attrs.get("eps", 0.001))
bn_node = onnx.helper.make_node(
"BatchNormalization",
input_nodes,
[name],
name=name,
epsilon=eps,
momentum=momentum,
# MXNet computes mean and variance per feature for batchnorm
# Default for onnx is across all spatial features. So disabling the parameter.
spatial=0
)
return [bn_node] | [
"def",
"convert_batchnorm",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"momentum",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"momentum\"",
",",
"0.9",
")",
")",
"eps",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"eps\"",
",",
"0.001",
")",
")",
"bn_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"BatchNormalization\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
",",
"epsilon",
"=",
"eps",
",",
"momentum",
"=",
"momentum",
",",
"# MXNet computes mean and variance per feature for batchnorm",
"# Default for onnx is across all spatial features. So disabling the parameter.",
"spatial",
"=",
"0",
")",
"return",
"[",
"bn_node",
"]"
] | Map MXNet's BatchNorm operator attributes to onnx's BatchNormalization operator
and return the created node. | [
"Map",
"MXNet",
"s",
"BatchNorm",
"operator",
"attributes",
"to",
"onnx",
"s",
"BatchNormalization",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L341-L361 |
23,618 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_pad | def convert_pad(node, **kwargs):
"""Map MXNet's pad operator attributes to onnx's Pad operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mxnet_pad_width = convert_string_to_list(attrs.get("pad_width"))
onnx_pad_width = transform_padding(mxnet_pad_width)
pad_mode = attrs.get("mode")
if pad_mode == "constant":
pad_value = float(attrs.get("constant_value")) \
if "constant_value" in attrs else 0.0
node = onnx.helper.make_node(
'Pad',
inputs=input_nodes,
outputs=[name],
mode='constant',
value=pad_value,
pads=onnx_pad_width,
name=name
)
else:
node = onnx.helper.make_node(
'Pad',
inputs=input_nodes,
outputs=[name],
mode=pad_mode,
pads=onnx_pad_width,
name=name
)
return [node] | python | def convert_pad(node, **kwargs):
"""Map MXNet's pad operator attributes to onnx's Pad operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mxnet_pad_width = convert_string_to_list(attrs.get("pad_width"))
onnx_pad_width = transform_padding(mxnet_pad_width)
pad_mode = attrs.get("mode")
if pad_mode == "constant":
pad_value = float(attrs.get("constant_value")) \
if "constant_value" in attrs else 0.0
node = onnx.helper.make_node(
'Pad',
inputs=input_nodes,
outputs=[name],
mode='constant',
value=pad_value,
pads=onnx_pad_width,
name=name
)
else:
node = onnx.helper.make_node(
'Pad',
inputs=input_nodes,
outputs=[name],
mode=pad_mode,
pads=onnx_pad_width,
name=name
)
return [node] | [
"def",
"convert_pad",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"mxnet_pad_width",
"=",
"convert_string_to_list",
"(",
"attrs",
".",
"get",
"(",
"\"pad_width\"",
")",
")",
"onnx_pad_width",
"=",
"transform_padding",
"(",
"mxnet_pad_width",
")",
"pad_mode",
"=",
"attrs",
".",
"get",
"(",
"\"mode\"",
")",
"if",
"pad_mode",
"==",
"\"constant\"",
":",
"pad_value",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"constant_value\"",
")",
")",
"if",
"\"constant_value\"",
"in",
"attrs",
"else",
"0.0",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Pad'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"mode",
"=",
"'constant'",
",",
"value",
"=",
"pad_value",
",",
"pads",
"=",
"onnx_pad_width",
",",
"name",
"=",
"name",
")",
"else",
":",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Pad'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"mode",
"=",
"pad_mode",
",",
"pads",
"=",
"onnx_pad_width",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's pad operator attributes to onnx's Pad operator
and return the created node. | [
"Map",
"MXNet",
"s",
"pad",
"operator",
"attributes",
"to",
"onnx",
"s",
"Pad",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L464-L497 |
23,619 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | create_helper_trans_node | def create_helper_trans_node(op_name, input_node, node_name):
"""create extra transpose node for dot operator"""
node_name = op_name + "_" + node_name
trans_node = onnx.helper.make_node(
'Transpose',
inputs=[input_node],
outputs=[node_name],
name=node_name
)
return trans_node | python | def create_helper_trans_node(op_name, input_node, node_name):
"""create extra transpose node for dot operator"""
node_name = op_name + "_" + node_name
trans_node = onnx.helper.make_node(
'Transpose',
inputs=[input_node],
outputs=[node_name],
name=node_name
)
return trans_node | [
"def",
"create_helper_trans_node",
"(",
"op_name",
",",
"input_node",
",",
"node_name",
")",
":",
"node_name",
"=",
"op_name",
"+",
"\"_\"",
"+",
"node_name",
"trans_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Transpose'",
",",
"inputs",
"=",
"[",
"input_node",
"]",
",",
"outputs",
"=",
"[",
"node_name",
"]",
",",
"name",
"=",
"node_name",
")",
"return",
"trans_node"
] | create extra transpose node for dot operator | [
"create",
"extra",
"transpose",
"node",
"for",
"dot",
"operator"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L500-L509 |
23,620 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_dot | def convert_dot(node, **kwargs):
"""Map MXNet's dot operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes."""
name, input_nodes, attrs = get_inputs(node, kwargs)
input_node_a = input_nodes[0]
input_node_b = input_nodes[1]
trans_a_node = None
trans_b_node = None
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, "transpose_b")
op_name = "transpose" + str(kwargs["idx"])
if trans_a:
trans_a_node = create_helper_trans_node(op_name, input_nodes[0], 'a')
input_node_a = op_name+"_a"
if trans_b:
trans_b_node = create_helper_trans_node(op_name, input_nodes[1], 'b')
input_node_b = op_name+"_b"
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[input_node_a, input_node_b],
outputs=[name],
name=name
)
if not trans_a and not trans_b:
return [matmul_node]
elif trans_a and not trans_b:
return [trans_a_node, matmul_node]
elif trans_b and not trans_a:
return [trans_b_node, matmul_node]
else:
return [trans_a_node, trans_b_node, matmul_node] | python | def convert_dot(node, **kwargs):
"""Map MXNet's dot operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes."""
name, input_nodes, attrs = get_inputs(node, kwargs)
input_node_a = input_nodes[0]
input_node_b = input_nodes[1]
trans_a_node = None
trans_b_node = None
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, "transpose_b")
op_name = "transpose" + str(kwargs["idx"])
if trans_a:
trans_a_node = create_helper_trans_node(op_name, input_nodes[0], 'a')
input_node_a = op_name+"_a"
if trans_b:
trans_b_node = create_helper_trans_node(op_name, input_nodes[1], 'b')
input_node_b = op_name+"_b"
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[input_node_a, input_node_b],
outputs=[name],
name=name
)
if not trans_a and not trans_b:
return [matmul_node]
elif trans_a and not trans_b:
return [trans_a_node, matmul_node]
elif trans_b and not trans_a:
return [trans_b_node, matmul_node]
else:
return [trans_a_node, trans_b_node, matmul_node] | [
"def",
"convert_dot",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"input_node_a",
"=",
"input_nodes",
"[",
"0",
"]",
"input_node_b",
"=",
"input_nodes",
"[",
"1",
"]",
"trans_a_node",
"=",
"None",
"trans_b_node",
"=",
"None",
"trans_a",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"transpose_a\"",
")",
"trans_b",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"transpose_b\"",
")",
"op_name",
"=",
"\"transpose\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"if",
"trans_a",
":",
"trans_a_node",
"=",
"create_helper_trans_node",
"(",
"op_name",
",",
"input_nodes",
"[",
"0",
"]",
",",
"'a'",
")",
"input_node_a",
"=",
"op_name",
"+",
"\"_a\"",
"if",
"trans_b",
":",
"trans_b_node",
"=",
"create_helper_trans_node",
"(",
"op_name",
",",
"input_nodes",
"[",
"1",
"]",
",",
"'b'",
")",
"input_node_b",
"=",
"op_name",
"+",
"\"_b\"",
"matmul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MatMul'",
",",
"inputs",
"=",
"[",
"input_node_a",
",",
"input_node_b",
"]",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"if",
"not",
"trans_a",
"and",
"not",
"trans_b",
":",
"return",
"[",
"matmul_node",
"]",
"elif",
"trans_a",
"and",
"not",
"trans_b",
":",
"return",
"[",
"trans_a_node",
",",
"matmul_node",
"]",
"elif",
"trans_b",
"and",
"not",
"trans_a",
":",
"return",
"[",
"trans_b_node",
",",
"matmul_node",
"]",
"else",
":",
"return",
"[",
"trans_a_node",
",",
"trans_b_node",
",",
"matmul_node",
"]"
] | Map MXNet's dot operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes. | [
"Map",
"MXNet",
"s",
"dot",
"operator",
"attributes",
"to",
"onnx",
"s",
"MatMul",
"and",
"Transpose",
"operators",
"based",
"on",
"the",
"values",
"set",
"for",
"transpose_a",
"transpose_b",
"attributes",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L513-L550 |
23,621 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_linalg_gemm2 | def convert_linalg_gemm2(node, **kwargs):
"""Map MXNet's _linalg_gemm2 operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes.
Return multiple nodes created.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Getting the attributes and assigning default values.
alpha = float(attrs.get("alpha", 1.0))
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, "transpose_b")
op_name = "transpose" + str(kwargs["idx"])
if alpha == 1.0 and trans_a == 0 and trans_b == 0:
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=input_nodes,
outputs=[name],
name=name
)
return [matmul_node]
elif trans_a == 1 and trans_b == 0:
op_name = "transpose" + str(kwargs["idx"])
node_name = op_name+"_a"
trans_a_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[0]],
outputs=[op_name+"_a"],
name=node_name
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[node_name, input_nodes[1]],
outputs=[name],
name=name
)
return [trans_a_node, matmul_node]
elif trans_a == 0 and trans_b == 1:
node_name = op_name + "_b"
trans_b_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[1]],
outputs=[op_name+"_b"],
name=node_name
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[input_nodes[0], node_name],
outputs=[name],
name=name
)
return [trans_b_node, matmul_node]
else:
node_name_a = op_name+"_a"
trans_a_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[0]],
outputs=[op_name+"_a"],
name=node_name_a
)
node_name_b = op_name + "_b"
trans_b_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[1]],
outputs=[op_name+"_b"],
name=node_name_b
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=input_nodes,
outputs=[name],
name=name
)
return [trans_a_node, trans_b_node, matmul_node] | python | def convert_linalg_gemm2(node, **kwargs):
"""Map MXNet's _linalg_gemm2 operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes.
Return multiple nodes created.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Getting the attributes and assigning default values.
alpha = float(attrs.get("alpha", 1.0))
trans_a = get_boolean_attribute_value(attrs, "transpose_a")
trans_b = get_boolean_attribute_value(attrs, "transpose_b")
op_name = "transpose" + str(kwargs["idx"])
if alpha == 1.0 and trans_a == 0 and trans_b == 0:
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=input_nodes,
outputs=[name],
name=name
)
return [matmul_node]
elif trans_a == 1 and trans_b == 0:
op_name = "transpose" + str(kwargs["idx"])
node_name = op_name+"_a"
trans_a_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[0]],
outputs=[op_name+"_a"],
name=node_name
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[node_name, input_nodes[1]],
outputs=[name],
name=name
)
return [trans_a_node, matmul_node]
elif trans_a == 0 and trans_b == 1:
node_name = op_name + "_b"
trans_b_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[1]],
outputs=[op_name+"_b"],
name=node_name
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=[input_nodes[0], node_name],
outputs=[name],
name=name
)
return [trans_b_node, matmul_node]
else:
node_name_a = op_name+"_a"
trans_a_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[0]],
outputs=[op_name+"_a"],
name=node_name_a
)
node_name_b = op_name + "_b"
trans_b_node = onnx.helper.make_node(
'Transpose',
inputs=[input_nodes[1]],
outputs=[op_name+"_b"],
name=node_name_b
)
matmul_node = onnx.helper.make_node(
'MatMul',
inputs=input_nodes,
outputs=[name],
name=name
)
return [trans_a_node, trans_b_node, matmul_node] | [
"def",
"convert_linalg_gemm2",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"# Getting the attributes and assigning default values.",
"alpha",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"alpha\"",
",",
"1.0",
")",
")",
"trans_a",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"transpose_a\"",
")",
"trans_b",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"transpose_b\"",
")",
"op_name",
"=",
"\"transpose\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"if",
"alpha",
"==",
"1.0",
"and",
"trans_a",
"==",
"0",
"and",
"trans_b",
"==",
"0",
":",
"matmul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MatMul'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"matmul_node",
"]",
"elif",
"trans_a",
"==",
"1",
"and",
"trans_b",
"==",
"0",
":",
"op_name",
"=",
"\"transpose\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"node_name",
"=",
"op_name",
"+",
"\"_a\"",
"trans_a_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Transpose'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"0",
"]",
"]",
",",
"outputs",
"=",
"[",
"op_name",
"+",
"\"_a\"",
"]",
",",
"name",
"=",
"node_name",
")",
"matmul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MatMul'",
",",
"inputs",
"=",
"[",
"node_name",
",",
"input_nodes",
"[",
"1",
"]",
"]",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"trans_a_node",
",",
"matmul_node",
"]",
"elif",
"trans_a",
"==",
"0",
"and",
"trans_b",
"==",
"1",
":",
"node_name",
"=",
"op_name",
"+",
"\"_b\"",
"trans_b_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Transpose'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"1",
"]",
"]",
",",
"outputs",
"=",
"[",
"op_name",
"+",
"\"_b\"",
"]",
",",
"name",
"=",
"node_name",
")",
"matmul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MatMul'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"0",
"]",
",",
"node_name",
"]",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"trans_b_node",
",",
"matmul_node",
"]",
"else",
":",
"node_name_a",
"=",
"op_name",
"+",
"\"_a\"",
"trans_a_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Transpose'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"0",
"]",
"]",
",",
"outputs",
"=",
"[",
"op_name",
"+",
"\"_a\"",
"]",
",",
"name",
"=",
"node_name_a",
")",
"node_name_b",
"=",
"op_name",
"+",
"\"_b\"",
"trans_b_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'Transpose'",
",",
"inputs",
"=",
"[",
"input_nodes",
"[",
"1",
"]",
"]",
",",
"outputs",
"=",
"[",
"op_name",
"+",
"\"_b\"",
"]",
",",
"name",
"=",
"node_name_b",
")",
"matmul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MatMul'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"trans_a_node",
",",
"trans_b_node",
",",
"matmul_node",
"]"
] | Map MXNet's _linalg_gemm2 operator attributes to onnx's
MatMul and Transpose operators based on the values set for
transpose_a, transpose_b attributes.
Return multiple nodes created. | [
"Map",
"MXNet",
"s",
"_linalg_gemm2",
"operator",
"attributes",
"to",
"onnx",
"s",
"MatMul",
"and",
"Transpose",
"operators",
"based",
"on",
"the",
"values",
"set",
"for",
"transpose_a",
"transpose_b",
"attributes",
".",
"Return",
"multiple",
"nodes",
"created",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L554-L636 |
23,622 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_instancenorm | def convert_instancenorm(node, **kwargs):
"""Map MXNet's InstanceNorm operator attributes to onnx's InstanceNormalization operator
based on the input node's attributes and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
eps = float(attrs.get("eps", 0.001))
node = onnx.helper.make_node(
'InstanceNormalization',
inputs=input_nodes,
outputs=[name],
name=name,
epsilon=eps)
return [node] | python | def convert_instancenorm(node, **kwargs):
"""Map MXNet's InstanceNorm operator attributes to onnx's InstanceNormalization operator
based on the input node's attributes and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
eps = float(attrs.get("eps", 0.001))
node = onnx.helper.make_node(
'InstanceNormalization',
inputs=input_nodes,
outputs=[name],
name=name,
epsilon=eps)
return [node] | [
"def",
"convert_instancenorm",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"eps",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"eps\"",
",",
"0.001",
")",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'InstanceNormalization'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
",",
"epsilon",
"=",
"eps",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's InstanceNorm operator attributes to onnx's InstanceNormalization operator
based on the input node's attributes and return the created node. | [
"Map",
"MXNet",
"s",
"InstanceNorm",
"operator",
"attributes",
"to",
"onnx",
"s",
"InstanceNormalization",
"operator",
"based",
"on",
"the",
"input",
"node",
"s",
"attributes",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L735-L750 |
23,623 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_softmax | def convert_softmax(node, **kwargs):
"""Map MXNet's softmax operator attributes to onnx's Softmax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis", -1))
softmax_node = onnx.helper.make_node(
"Softmax",
input_nodes,
[name],
axis=axis,
name=name
)
return [softmax_node] | python | def convert_softmax(node, **kwargs):
"""Map MXNet's softmax operator attributes to onnx's Softmax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis", -1))
softmax_node = onnx.helper.make_node(
"Softmax",
input_nodes,
[name],
axis=axis,
name=name
)
return [softmax_node] | [
"def",
"convert_softmax",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"-",
"1",
")",
")",
"softmax_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Softmax\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axis",
"=",
"axis",
",",
"name",
"=",
"name",
")",
"return",
"[",
"softmax_node",
"]"
] | Map MXNet's softmax operator attributes to onnx's Softmax operator
and return the created node. | [
"Map",
"MXNet",
"s",
"softmax",
"operator",
"attributes",
"to",
"onnx",
"s",
"Softmax",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L783-L799 |
23,624 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_concat | def convert_concat(node, **kwargs):
"""Map MXNet's Concat operator attributes to onnx's Concat operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("dim", 1))
concat_node = onnx.helper.make_node(
"Concat",
input_nodes,
[name],
axis=axis,
name=name
)
return [concat_node] | python | def convert_concat(node, **kwargs):
"""Map MXNet's Concat operator attributes to onnx's Concat operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("dim", 1))
concat_node = onnx.helper.make_node(
"Concat",
input_nodes,
[name],
axis=axis,
name=name
)
return [concat_node] | [
"def",
"convert_concat",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"dim\"",
",",
"1",
")",
")",
"concat_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Concat\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axis",
"=",
"axis",
",",
"name",
"=",
"name",
")",
"return",
"[",
"concat_node",
"]"
] | Map MXNet's Concat operator attributes to onnx's Concat operator
and return the created node. | [
"Map",
"MXNet",
"s",
"Concat",
"operator",
"attributes",
"to",
"onnx",
"s",
"Concat",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L851-L865 |
23,625 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_transpose | def convert_transpose(node, **kwargs):
"""Map MXNet's transpose operator attributes to onnx's Transpose operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axes = attrs.get("axes", ())
if axes:
axes = tuple(map(int, re.findall(r'\d+', axes)))
transpose_node = onnx.helper.make_node(
"Transpose",
input_nodes,
[name],
perm=axes,
name=name
)
else:
transpose_node = onnx.helper.make_node(
"Transpose",
input_nodes,
[name],
name=name
)
return [transpose_node] | python | def convert_transpose(node, **kwargs):
"""Map MXNet's transpose operator attributes to onnx's Transpose operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axes = attrs.get("axes", ())
if axes:
axes = tuple(map(int, re.findall(r'\d+', axes)))
transpose_node = onnx.helper.make_node(
"Transpose",
input_nodes,
[name],
perm=axes,
name=name
)
else:
transpose_node = onnx.helper.make_node(
"Transpose",
input_nodes,
[name],
name=name
)
return [transpose_node] | [
"def",
"convert_transpose",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axes",
"=",
"attrs",
".",
"get",
"(",
"\"axes\"",
",",
"(",
")",
")",
"if",
"axes",
":",
"axes",
"=",
"tuple",
"(",
"map",
"(",
"int",
",",
"re",
".",
"findall",
"(",
"r'\\d+'",
",",
"axes",
")",
")",
")",
"transpose_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Transpose\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"perm",
"=",
"axes",
",",
"name",
"=",
"name",
")",
"else",
":",
"transpose_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Transpose\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"transpose_node",
"]"
] | Map MXNet's transpose operator attributes to onnx's Transpose operator
and return the created node. | [
"Map",
"MXNet",
"s",
"transpose",
"operator",
"attributes",
"to",
"onnx",
"s",
"Transpose",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L869-L894 |
23,626 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_lrn | def convert_lrn(node, **kwargs):
"""Map MXNet's LRN operator attributes to onnx's LRN operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
alpha = float(attrs.get("alpha", 0.0001))
beta = float(attrs.get("beta", 0.75))
bias = float(attrs.get("knorm", 1.0))
size = int(attrs.get("nsize"))
lrn_node = onnx.helper.make_node(
"LRN",
inputs=input_nodes,
outputs=[name],
name=name,
alpha=alpha,
beta=beta,
bias=bias,
size=size
)
return [lrn_node] | python | def convert_lrn(node, **kwargs):
"""Map MXNet's LRN operator attributes to onnx's LRN operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
alpha = float(attrs.get("alpha", 0.0001))
beta = float(attrs.get("beta", 0.75))
bias = float(attrs.get("knorm", 1.0))
size = int(attrs.get("nsize"))
lrn_node = onnx.helper.make_node(
"LRN",
inputs=input_nodes,
outputs=[name],
name=name,
alpha=alpha,
beta=beta,
bias=bias,
size=size
)
return [lrn_node] | [
"def",
"convert_lrn",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"alpha",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"alpha\"",
",",
"0.0001",
")",
")",
"beta",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"beta\"",
",",
"0.75",
")",
")",
"bias",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"knorm\"",
",",
"1.0",
")",
")",
"size",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"nsize\"",
")",
")",
"lrn_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"LRN\"",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
",",
"alpha",
"=",
"alpha",
",",
"beta",
"=",
"beta",
",",
"bias",
"=",
"bias",
",",
"size",
"=",
"size",
")",
"return",
"[",
"lrn_node",
"]"
] | Map MXNet's LRN operator attributes to onnx's LRN operator
and return the created node. | [
"Map",
"MXNet",
"s",
"LRN",
"operator",
"attributes",
"to",
"onnx",
"s",
"LRN",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L898-L920 |
23,627 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_l2normalization | def convert_l2normalization(node, **kwargs):
"""Map MXNet's L2Normalization operator attributes to onnx's LpNormalization operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mode = attrs.get("mode", "instance")
if mode != "channel":
raise AttributeError("L2Normalization: ONNX currently supports channel mode only")
l2norm_node = onnx.helper.make_node(
"LpNormalization",
input_nodes,
[name],
axis=1, # channel only
name=name
)
return [l2norm_node] | python | def convert_l2normalization(node, **kwargs):
"""Map MXNet's L2Normalization operator attributes to onnx's LpNormalization operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mode = attrs.get("mode", "instance")
if mode != "channel":
raise AttributeError("L2Normalization: ONNX currently supports channel mode only")
l2norm_node = onnx.helper.make_node(
"LpNormalization",
input_nodes,
[name],
axis=1, # channel only
name=name
)
return [l2norm_node] | [
"def",
"convert_l2normalization",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"mode",
"=",
"attrs",
".",
"get",
"(",
"\"mode\"",
",",
"\"instance\"",
")",
"if",
"mode",
"!=",
"\"channel\"",
":",
"raise",
"AttributeError",
"(",
"\"L2Normalization: ONNX currently supports channel mode only\"",
")",
"l2norm_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"LpNormalization\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axis",
"=",
"1",
",",
"# channel only",
"name",
"=",
"name",
")",
"return",
"[",
"l2norm_node",
"]"
] | Map MXNet's L2Normalization operator attributes to onnx's LpNormalization operator
and return the created node. | [
"Map",
"MXNet",
"s",
"L2Normalization",
"operator",
"attributes",
"to",
"onnx",
"s",
"LpNormalization",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L924-L942 |
23,628 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_dropout | def convert_dropout(node, **kwargs):
"""Map MXNet's Dropout operator attributes to onnx's Dropout operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
probability = float(attrs.get("p", 0.5))
dropout_node = onnx.helper.make_node(
"Dropout",
input_nodes,
[name],
ratio=probability,
name=name
)
return [dropout_node] | python | def convert_dropout(node, **kwargs):
"""Map MXNet's Dropout operator attributes to onnx's Dropout operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
probability = float(attrs.get("p", 0.5))
dropout_node = onnx.helper.make_node(
"Dropout",
input_nodes,
[name],
ratio=probability,
name=name
)
return [dropout_node] | [
"def",
"convert_dropout",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"probability",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"p\"",
",",
"0.5",
")",
")",
"dropout_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Dropout\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"ratio",
"=",
"probability",
",",
"name",
"=",
"name",
")",
"return",
"[",
"dropout_node",
"]"
] | Map MXNet's Dropout operator attributes to onnx's Dropout operator
and return the created node. | [
"Map",
"MXNet",
"s",
"Dropout",
"operator",
"attributes",
"to",
"onnx",
"s",
"Dropout",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L946-L961 |
23,629 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_clip | def convert_clip(node, **kwargs):
"""Map MXNet's Clip operator attributes to onnx's Clip operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
a_min = np.float(attrs.get('a_min', -np.inf))
a_max = np.float(attrs.get('a_max', np.inf))
clip_node = onnx.helper.make_node(
"Clip",
input_nodes,
[name],
name=name,
min=a_min,
max=a_max
)
return [clip_node] | python | def convert_clip(node, **kwargs):
"""Map MXNet's Clip operator attributes to onnx's Clip operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
a_min = np.float(attrs.get('a_min', -np.inf))
a_max = np.float(attrs.get('a_max', np.inf))
clip_node = onnx.helper.make_node(
"Clip",
input_nodes,
[name],
name=name,
min=a_min,
max=a_max
)
return [clip_node] | [
"def",
"convert_clip",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"a_min",
"=",
"np",
".",
"float",
"(",
"attrs",
".",
"get",
"(",
"'a_min'",
",",
"-",
"np",
".",
"inf",
")",
")",
"a_max",
"=",
"np",
".",
"float",
"(",
"attrs",
".",
"get",
"(",
"'a_max'",
",",
"np",
".",
"inf",
")",
")",
"clip_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Clip\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
",",
"min",
"=",
"a_min",
",",
"max",
"=",
"a_max",
")",
"return",
"[",
"clip_node",
"]"
] | Map MXNet's Clip operator attributes to onnx's Clip operator
and return the created node. | [
"Map",
"MXNet",
"s",
"Clip",
"operator",
"attributes",
"to",
"onnx",
"s",
"Clip",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L972-L989 |
23,630 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | scalar_op_helper | def scalar_op_helper(node, op_name, **kwargs):
"""Helper function for scalar arithmetic operations"""
name, input_nodes, attrs = get_inputs(node, kwargs)
from onnx import numpy_helper
input_type = kwargs["in_type"]
scalar_value = np.array([attrs.get("scalar", 1)],
dtype=onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[input_type])
initializer = kwargs["initializer"]
flag = True
# If the input value is in initializer, just multiply with scalar input
# and create a new initializer
for i in initializer:
if i.name == input_nodes[0]:
if op_name == 'Mul':
new_initializer = numpy_helper.to_array(i) * scalar_value[0]
elif op_name == 'Sub':
if name.startswith("_rminusscalar"):
new_initializer = scalar_value[0] - numpy_helper.to_array(i)
else:
new_initializer = numpy_helper.to_array(i) - scalar_value[0]
elif op_name == 'Add':
new_initializer = numpy_helper.to_array(i) + scalar_value[0]
elif op_name == 'Div':
if name.startswith("_rdivscalar"):
new_initializer = scalar_value[0] / numpy_helper.to_array(i)
else:
new_initializer = numpy_helper.to_array(i) / scalar_value[0]
elif op_name == 'Pow':
new_initializer = numpy_helper.to_array(i) ** scalar_value[0]
flag = False
break
# else create a new tensor of the scalar value, add it in initializer
if flag is True:
dims = np.shape(scalar_value)
scalar_op_name = "scalar_op" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(scalar_op_name, input_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=scalar_op_name,
data_type=input_type,
dims=dims,
vals=scalar_value,
raw=False,
)
)
mul_node = onnx.helper.make_node(
op_name,
[input_nodes[0], scalar_op_name],
[name],
name=name
)
return [tensor_node, mul_node]
else:
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[new_initializer.dtype]
dims = np.shape(new_initializer)
new_a_node = input_nodes[0] + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(new_a_node, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=new_a_node,
data_type=data_type,
dims=dims,
vals=new_initializer,
raw=False,
)
)
return [tensor_node] | python | def scalar_op_helper(node, op_name, **kwargs):
"""Helper function for scalar arithmetic operations"""
name, input_nodes, attrs = get_inputs(node, kwargs)
from onnx import numpy_helper
input_type = kwargs["in_type"]
scalar_value = np.array([attrs.get("scalar", 1)],
dtype=onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[input_type])
initializer = kwargs["initializer"]
flag = True
# If the input value is in initializer, just multiply with scalar input
# and create a new initializer
for i in initializer:
if i.name == input_nodes[0]:
if op_name == 'Mul':
new_initializer = numpy_helper.to_array(i) * scalar_value[0]
elif op_name == 'Sub':
if name.startswith("_rminusscalar"):
new_initializer = scalar_value[0] - numpy_helper.to_array(i)
else:
new_initializer = numpy_helper.to_array(i) - scalar_value[0]
elif op_name == 'Add':
new_initializer = numpy_helper.to_array(i) + scalar_value[0]
elif op_name == 'Div':
if name.startswith("_rdivscalar"):
new_initializer = scalar_value[0] / numpy_helper.to_array(i)
else:
new_initializer = numpy_helper.to_array(i) / scalar_value[0]
elif op_name == 'Pow':
new_initializer = numpy_helper.to_array(i) ** scalar_value[0]
flag = False
break
# else create a new tensor of the scalar value, add it in initializer
if flag is True:
dims = np.shape(scalar_value)
scalar_op_name = "scalar_op" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(scalar_op_name, input_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=scalar_op_name,
data_type=input_type,
dims=dims,
vals=scalar_value,
raw=False,
)
)
mul_node = onnx.helper.make_node(
op_name,
[input_nodes[0], scalar_op_name],
[name],
name=name
)
return [tensor_node, mul_node]
else:
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[new_initializer.dtype]
dims = np.shape(new_initializer)
new_a_node = input_nodes[0] + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(new_a_node, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=new_a_node,
data_type=data_type,
dims=dims,
vals=new_initializer,
raw=False,
)
)
return [tensor_node] | [
"def",
"scalar_op_helper",
"(",
"node",
",",
"op_name",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"from",
"onnx",
"import",
"numpy_helper",
"input_type",
"=",
"kwargs",
"[",
"\"in_type\"",
"]",
"scalar_value",
"=",
"np",
".",
"array",
"(",
"[",
"attrs",
".",
"get",
"(",
"\"scalar\"",
",",
"1",
")",
"]",
",",
"dtype",
"=",
"onnx",
".",
"mapping",
".",
"TENSOR_TYPE_TO_NP_TYPE",
"[",
"input_type",
"]",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"flag",
"=",
"True",
"# If the input value is in initializer, just multiply with scalar input",
"# and create a new initializer",
"for",
"i",
"in",
"initializer",
":",
"if",
"i",
".",
"name",
"==",
"input_nodes",
"[",
"0",
"]",
":",
"if",
"op_name",
"==",
"'Mul'",
":",
"new_initializer",
"=",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"*",
"scalar_value",
"[",
"0",
"]",
"elif",
"op_name",
"==",
"'Sub'",
":",
"if",
"name",
".",
"startswith",
"(",
"\"_rminusscalar\"",
")",
":",
"new_initializer",
"=",
"scalar_value",
"[",
"0",
"]",
"-",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"else",
":",
"new_initializer",
"=",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"-",
"scalar_value",
"[",
"0",
"]",
"elif",
"op_name",
"==",
"'Add'",
":",
"new_initializer",
"=",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"+",
"scalar_value",
"[",
"0",
"]",
"elif",
"op_name",
"==",
"'Div'",
":",
"if",
"name",
".",
"startswith",
"(",
"\"_rdivscalar\"",
")",
":",
"new_initializer",
"=",
"scalar_value",
"[",
"0",
"]",
"/",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"else",
":",
"new_initializer",
"=",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"/",
"scalar_value",
"[",
"0",
"]",
"elif",
"op_name",
"==",
"'Pow'",
":",
"new_initializer",
"=",
"numpy_helper",
".",
"to_array",
"(",
"i",
")",
"**",
"scalar_value",
"[",
"0",
"]",
"flag",
"=",
"False",
"break",
"# else create a new tensor of the scalar value, add it in initializer",
"if",
"flag",
"is",
"True",
":",
"dims",
"=",
"np",
".",
"shape",
"(",
"scalar_value",
")",
"scalar_op_name",
"=",
"\"scalar_op\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"scalar_op_name",
",",
"input_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"scalar_op_name",
",",
"data_type",
"=",
"input_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"scalar_value",
",",
"raw",
"=",
"False",
",",
")",
")",
"mul_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"op_name",
",",
"[",
"input_nodes",
"[",
"0",
"]",
",",
"scalar_op_name",
"]",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"tensor_node",
",",
"mul_node",
"]",
"else",
":",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"new_initializer",
".",
"dtype",
"]",
"dims",
"=",
"np",
".",
"shape",
"(",
"new_initializer",
")",
"new_a_node",
"=",
"input_nodes",
"[",
"0",
"]",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"new_a_node",
",",
"data_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"new_a_node",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"new_initializer",
",",
"raw",
"=",
"False",
",",
")",
")",
"return",
"[",
"tensor_node",
"]"
] | Helper function for scalar arithmetic operations | [
"Helper",
"function",
"for",
"scalar",
"arithmetic",
"operations"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L992-L1066 |
23,631 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_argmax | def convert_argmax(node, **kwargs):
"""Map MXNet's argmax operator attributes to onnx's ArgMax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
keepdims = get_boolean_attribute_value(attrs, "keepdims")
node = onnx.helper.make_node(
'ArgMax',
inputs=input_nodes,
axis=axis,
keepdims=keepdims,
outputs=[name],
name=name
)
return [node] | python | def convert_argmax(node, **kwargs):
"""Map MXNet's argmax operator attributes to onnx's ArgMax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
keepdims = get_boolean_attribute_value(attrs, "keepdims")
node = onnx.helper.make_node(
'ArgMax',
inputs=input_nodes,
axis=axis,
keepdims=keepdims,
outputs=[name],
name=name
)
return [node] | [
"def",
"convert_argmax",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
")",
")",
"keepdims",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"keepdims\"",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'ArgMax'",
",",
"inputs",
"=",
"input_nodes",
",",
"axis",
"=",
"axis",
",",
"keepdims",
"=",
"keepdims",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's argmax operator attributes to onnx's ArgMax operator
and return the created node. | [
"Map",
"MXNet",
"s",
"argmax",
"operator",
"attributes",
"to",
"onnx",
"s",
"ArgMax",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1131-L1148 |
23,632 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_reshape | def convert_reshape(node, **kwargs):
"""Map MXNet's Reshape operator attributes to onnx's Reshape operator.
Converts output shape attribute to output shape tensor
and return multiple created nodes.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
output_shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(output_shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[output_shape_np.dtype]
dims = np.shape(output_shape_np)
output_shape_name = "reshape_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=output_shape_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
not_supported_shape = [-2, -3, -4]
for val in output_shape_list:
if val in not_supported_shape:
raise AttributeError("Reshape: Shape value not supported in ONNX", val)
reshape_node = onnx.helper.make_node(
"Reshape",
input_nodes,
[name],
name=name
)
return [tensor_node, reshape_node] | python | def convert_reshape(node, **kwargs):
"""Map MXNet's Reshape operator attributes to onnx's Reshape operator.
Converts output shape attribute to output shape tensor
and return multiple created nodes.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
output_shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(output_shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[output_shape_np.dtype]
dims = np.shape(output_shape_np)
output_shape_name = "reshape_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=output_shape_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
not_supported_shape = [-2, -3, -4]
for val in output_shape_list:
if val in not_supported_shape:
raise AttributeError("Reshape: Shape value not supported in ONNX", val)
reshape_node = onnx.helper.make_node(
"Reshape",
input_nodes,
[name],
name=name
)
return [tensor_node, reshape_node] | [
"def",
"convert_reshape",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"output_shape_list",
"=",
"convert_string_to_list",
"(",
"attrs",
"[",
"\"shape\"",
"]",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"output_shape_np",
"=",
"np",
".",
"array",
"(",
"output_shape_list",
",",
"dtype",
"=",
"'int64'",
")",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"output_shape_np",
".",
"dtype",
"]",
"dims",
"=",
"np",
".",
"shape",
"(",
"output_shape_np",
")",
"output_shape_name",
"=",
"\"reshape_attr_tensor\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"output_shape_name",
",",
"data_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"output_shape_name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"output_shape_list",
",",
"raw",
"=",
"False",
",",
")",
")",
"input_nodes",
".",
"append",
"(",
"output_shape_name",
")",
"not_supported_shape",
"=",
"[",
"-",
"2",
",",
"-",
"3",
",",
"-",
"4",
"]",
"for",
"val",
"in",
"output_shape_list",
":",
"if",
"val",
"in",
"not_supported_shape",
":",
"raise",
"AttributeError",
"(",
"\"Reshape: Shape value not supported in ONNX\"",
",",
"val",
")",
"reshape_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Reshape\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"tensor_node",
",",
"reshape_node",
"]"
] | Map MXNet's Reshape operator attributes to onnx's Reshape operator.
Converts output shape attribute to output shape tensor
and return multiple created nodes. | [
"Map",
"MXNet",
"s",
"Reshape",
"operator",
"attributes",
"to",
"onnx",
"s",
"Reshape",
"operator",
".",
"Converts",
"output",
"shape",
"attribute",
"to",
"output",
"shape",
"tensor",
"and",
"return",
"multiple",
"created",
"nodes",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1422-L1464 |
23,633 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_cast | def convert_cast(node, **kwargs):
"""Map MXNet's Cast operator attributes to onnx's Cast operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
dtype = attrs["dtype"]
# dtype can be mapped only with types from TensorProto
# float32 is mapped to float and float64 to double in onnx
# following tensorproto mapping https://github.com/onnx/onnx/blob/master/onnx/mapping.py
if dtype == 'float32':
dtype = 'float'
elif dtype == 'float64':
dtype = 'double'
node = onnx.helper.make_node(
"Cast",
input_nodes,
[name],
to=getattr(onnx.TensorProto, dtype.upper()),
name=name,
)
return [node] | python | def convert_cast(node, **kwargs):
"""Map MXNet's Cast operator attributes to onnx's Cast operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
dtype = attrs["dtype"]
# dtype can be mapped only with types from TensorProto
# float32 is mapped to float and float64 to double in onnx
# following tensorproto mapping https://github.com/onnx/onnx/blob/master/onnx/mapping.py
if dtype == 'float32':
dtype = 'float'
elif dtype == 'float64':
dtype = 'double'
node = onnx.helper.make_node(
"Cast",
input_nodes,
[name],
to=getattr(onnx.TensorProto, dtype.upper()),
name=name,
)
return [node] | [
"def",
"convert_cast",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"dtype",
"=",
"attrs",
"[",
"\"dtype\"",
"]",
"# dtype can be mapped only with types from TensorProto",
"# float32 is mapped to float and float64 to double in onnx",
"# following tensorproto mapping https://github.com/onnx/onnx/blob/master/onnx/mapping.py",
"if",
"dtype",
"==",
"'float32'",
":",
"dtype",
"=",
"'float'",
"elif",
"dtype",
"==",
"'float64'",
":",
"dtype",
"=",
"'double'",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Cast\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"to",
"=",
"getattr",
"(",
"onnx",
".",
"TensorProto",
",",
"dtype",
".",
"upper",
"(",
")",
")",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's Cast operator attributes to onnx's Cast operator
and return the created node. | [
"Map",
"MXNet",
"s",
"Cast",
"operator",
"attributes",
"to",
"onnx",
"s",
"Cast",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1467-L1490 |
23,634 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_slice_axis | def convert_slice_axis(node, **kwargs):
"""Map MXNet's slice_axis operator attributes to onnx's Slice operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axes = int(attrs.get("axis"))
starts = int(attrs.get("begin"))
ends = int(attrs.get("end", None))
if not ends:
raise ValueError("Slice: ONNX doesnt't support 'None' in 'end' attribute")
node = onnx.helper.make_node(
"Slice",
input_nodes,
[name],
axes=[axes],
starts=[starts],
ends=[ends],
name=name,
)
return [node] | python | def convert_slice_axis(node, **kwargs):
"""Map MXNet's slice_axis operator attributes to onnx's Slice operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axes = int(attrs.get("axis"))
starts = int(attrs.get("begin"))
ends = int(attrs.get("end", None))
if not ends:
raise ValueError("Slice: ONNX doesnt't support 'None' in 'end' attribute")
node = onnx.helper.make_node(
"Slice",
input_nodes,
[name],
axes=[axes],
starts=[starts],
ends=[ends],
name=name,
)
return [node] | [
"def",
"convert_slice_axis",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axes",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
")",
")",
"starts",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"begin\"",
")",
")",
"ends",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"end\"",
",",
"None",
")",
")",
"if",
"not",
"ends",
":",
"raise",
"ValueError",
"(",
"\"Slice: ONNX doesnt't support 'None' in 'end' attribute\"",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Slice\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axes",
"=",
"[",
"axes",
"]",
",",
"starts",
"=",
"[",
"starts",
"]",
",",
"ends",
"=",
"[",
"ends",
"]",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's slice_axis operator attributes to onnx's Slice operator
and return the created node. | [
"Map",
"MXNet",
"s",
"slice_axis",
"operator",
"attributes",
"to",
"onnx",
"s",
"Slice",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1494-L1515 |
23,635 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_slice_channel | def convert_slice_channel(node, **kwargs):
"""Map MXNet's SliceChannel operator attributes to onnx's Squeeze or Split
operator based on squeeze_axis attribute
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
num_outputs = int(attrs.get("num_outputs"))
axis = int(attrs.get("axis", 1))
squeeze_axis = int(attrs.get("squeeze_axis", 0))
if squeeze_axis == 1 and num_outputs == 1:
node = onnx.helper.make_node(
"Squeeze",
input_nodes,
[name],
axes=[axis],
name=name,
)
return [node]
elif squeeze_axis == 0 and num_outputs > 1:
in_shape = kwargs.get('in_shape')[0]
split = in_shape[axis] // num_outputs
node = onnx.helper.make_node(
"Split",
input_nodes,
[name+'_output'+str(i) for i in range(num_outputs)],
axis=axis,
split=[split for _ in range(num_outputs)],
name=name,
)
return [node]
else:
raise NotImplementedError("SliceChannel operator with num_outputs>1 and"
"squeeze_axis true is not implemented.") | python | def convert_slice_channel(node, **kwargs):
"""Map MXNet's SliceChannel operator attributes to onnx's Squeeze or Split
operator based on squeeze_axis attribute
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
num_outputs = int(attrs.get("num_outputs"))
axis = int(attrs.get("axis", 1))
squeeze_axis = int(attrs.get("squeeze_axis", 0))
if squeeze_axis == 1 and num_outputs == 1:
node = onnx.helper.make_node(
"Squeeze",
input_nodes,
[name],
axes=[axis],
name=name,
)
return [node]
elif squeeze_axis == 0 and num_outputs > 1:
in_shape = kwargs.get('in_shape')[0]
split = in_shape[axis] // num_outputs
node = onnx.helper.make_node(
"Split",
input_nodes,
[name+'_output'+str(i) for i in range(num_outputs)],
axis=axis,
split=[split for _ in range(num_outputs)],
name=name,
)
return [node]
else:
raise NotImplementedError("SliceChannel operator with num_outputs>1 and"
"squeeze_axis true is not implemented.") | [
"def",
"convert_slice_channel",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"num_outputs",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"num_outputs\"",
")",
")",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"1",
")",
")",
"squeeze_axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"squeeze_axis\"",
",",
"0",
")",
")",
"if",
"squeeze_axis",
"==",
"1",
"and",
"num_outputs",
"==",
"1",
":",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Squeeze\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axes",
"=",
"[",
"axis",
"]",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]",
"elif",
"squeeze_axis",
"==",
"0",
"and",
"num_outputs",
">",
"1",
":",
"in_shape",
"=",
"kwargs",
".",
"get",
"(",
"'in_shape'",
")",
"[",
"0",
"]",
"split",
"=",
"in_shape",
"[",
"axis",
"]",
"//",
"num_outputs",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Split\"",
",",
"input_nodes",
",",
"[",
"name",
"+",
"'_output'",
"+",
"str",
"(",
"i",
")",
"for",
"i",
"in",
"range",
"(",
"num_outputs",
")",
"]",
",",
"axis",
"=",
"axis",
",",
"split",
"=",
"[",
"split",
"for",
"_",
"in",
"range",
"(",
"num_outputs",
")",
"]",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]",
"else",
":",
"raise",
"NotImplementedError",
"(",
"\"SliceChannel operator with num_outputs>1 and\"",
"\"squeeze_axis true is not implemented.\"",
")"
] | Map MXNet's SliceChannel operator attributes to onnx's Squeeze or Split
operator based on squeeze_axis attribute
and return the created node. | [
"Map",
"MXNet",
"s",
"SliceChannel",
"operator",
"attributes",
"to",
"onnx",
"s",
"Squeeze",
"or",
"Split",
"operator",
"based",
"on",
"squeeze_axis",
"attribute",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1519-L1553 |
23,636 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_expand_dims | def convert_expand_dims(node, **kwargs):
"""Map MXNet's expand_dims operator attributes to onnx's Unsqueeze operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
node = onnx.helper.make_node(
"Unsqueeze",
input_nodes,
[name],
axes=[axis],
name=name,
)
return [node] | python | def convert_expand_dims(node, **kwargs):
"""Map MXNet's expand_dims operator attributes to onnx's Unsqueeze operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = int(attrs.get("axis"))
node = onnx.helper.make_node(
"Unsqueeze",
input_nodes,
[name],
axes=[axis],
name=name,
)
return [node] | [
"def",
"convert_expand_dims",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
")",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Unsqueeze\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axes",
"=",
"[",
"axis",
"]",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's expand_dims operator attributes to onnx's Unsqueeze operator
and return the created node. | [
"Map",
"MXNet",
"s",
"expand_dims",
"operator",
"attributes",
"to",
"onnx",
"s",
"Unsqueeze",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1557-L1572 |
23,637 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_squeeze | def convert_squeeze(node, **kwargs):
"""Map MXNet's squeeze operator attributes to onnx's squeeze operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = attrs.get("axis", None)
if not axis:
raise AttributeError("Squeeze: Missing axis attribute: ONNX currently requires axis to "
"be specified for squeeze operator")
axis = convert_string_to_list(axis)
node = onnx.helper.make_node(
"Squeeze",
input_nodes,
[name],
axes=axis,
name=name,
)
return [node] | python | def convert_squeeze(node, **kwargs):
"""Map MXNet's squeeze operator attributes to onnx's squeeze operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
axis = attrs.get("axis", None)
if not axis:
raise AttributeError("Squeeze: Missing axis attribute: ONNX currently requires axis to "
"be specified for squeeze operator")
axis = convert_string_to_list(axis)
node = onnx.helper.make_node(
"Squeeze",
input_nodes,
[name],
axes=axis,
name=name,
)
return [node] | [
"def",
"convert_squeeze",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"axis",
"=",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"None",
")",
"if",
"not",
"axis",
":",
"raise",
"AttributeError",
"(",
"\"Squeeze: Missing axis attribute: ONNX currently requires axis to \"",
"\"be specified for squeeze operator\"",
")",
"axis",
"=",
"convert_string_to_list",
"(",
"axis",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Squeeze\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axes",
"=",
"axis",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's squeeze operator attributes to onnx's squeeze operator
and return the created node. | [
"Map",
"MXNet",
"s",
"squeeze",
"operator",
"attributes",
"to",
"onnx",
"s",
"squeeze",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1575-L1594 |
23,638 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_depthtospace | def convert_depthtospace(node, **kwargs):
"""Map MXNet's depth_to_space operator attributes to onnx's
DepthToSpace operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
blksize = int(attrs.get("block_size", 0))
node = onnx.helper.make_node(
"DepthToSpace",
input_nodes,
[name],
blocksize=blksize,
name=name,
)
return [node] | python | def convert_depthtospace(node, **kwargs):
"""Map MXNet's depth_to_space operator attributes to onnx's
DepthToSpace operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
blksize = int(attrs.get("block_size", 0))
node = onnx.helper.make_node(
"DepthToSpace",
input_nodes,
[name],
blocksize=blksize,
name=name,
)
return [node] | [
"def",
"convert_depthtospace",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"blksize",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"block_size\"",
",",
"0",
")",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"DepthToSpace\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"blocksize",
"=",
"blksize",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's depth_to_space operator attributes to onnx's
DepthToSpace operator and return the created node. | [
"Map",
"MXNet",
"s",
"depth_to_space",
"operator",
"attributes",
"to",
"onnx",
"s",
"DepthToSpace",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1633-L1648 |
23,639 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_square | def convert_square(node, **kwargs):
"""Map MXNet's square operator attributes to onnx's Pow operator
and return the created node.
"""
name, input_nodes, _ = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]
power2_name = "square_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(power2_name, data_type, (1,))
initializer.append(
onnx.helper.make_tensor(
name=power2_name,
data_type=data_type,
dims=(1,),
vals=[2],
raw=False,
)
)
input_nodes.append(power2_name)
node = onnx.helper.make_node(
"Pow",
input_nodes,
[name],
name=name
)
return [tensor_node, node] | python | def convert_square(node, **kwargs):
"""Map MXNet's square operator attributes to onnx's Pow operator
and return the created node.
"""
name, input_nodes, _ = get_inputs(node, kwargs)
initializer = kwargs["initializer"]
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]
power2_name = "square_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(power2_name, data_type, (1,))
initializer.append(
onnx.helper.make_tensor(
name=power2_name,
data_type=data_type,
dims=(1,),
vals=[2],
raw=False,
)
)
input_nodes.append(power2_name)
node = onnx.helper.make_node(
"Pow",
input_nodes,
[name],
name=name
)
return [tensor_node, node] | [
"def",
"convert_square",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"_",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np",
".",
"dtype",
"(",
"'int64'",
")",
"]",
"power2_name",
"=",
"\"square_tensor\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"power2_name",
",",
"data_type",
",",
"(",
"1",
",",
")",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"power2_name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"(",
"1",
",",
")",
",",
"vals",
"=",
"[",
"2",
"]",
",",
"raw",
"=",
"False",
",",
")",
")",
"input_nodes",
".",
"append",
"(",
"power2_name",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Pow\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"tensor_node",
",",
"node",
"]"
] | Map MXNet's square operator attributes to onnx's Pow operator
and return the created node. | [
"Map",
"MXNet",
"s",
"square",
"operator",
"attributes",
"to",
"onnx",
"s",
"Pow",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1669-L1698 |
23,640 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_sum | def convert_sum(node, **kwargs):
"""Map MXNet's sum operator attributes to onnx's ReduceSum operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes:
node = onnx.helper.make_node(
'ReduceSum',
inputs=input_nodes,
outputs=[name],
axes=axes,
keepdims=keepdims,
name=name
)
else:
node = onnx.helper.make_node(
'ReduceSum',
inputs=input_nodes,
outputs=[name],
keepdims=keepdims,
name=name
)
return [node] | python | def convert_sum(node, **kwargs):
"""Map MXNet's sum operator attributes to onnx's ReduceSum operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
if axes:
node = onnx.helper.make_node(
'ReduceSum',
inputs=input_nodes,
outputs=[name],
axes=axes,
keepdims=keepdims,
name=name
)
else:
node = onnx.helper.make_node(
'ReduceSum',
inputs=input_nodes,
outputs=[name],
keepdims=keepdims,
name=name
)
return [node] | [
"def",
"convert_sum",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"mx_axis",
"=",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"None",
")",
"axes",
"=",
"convert_string_to_list",
"(",
"str",
"(",
"mx_axis",
")",
")",
"if",
"mx_axis",
"is",
"not",
"None",
"else",
"None",
"keepdims",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"keepdims\"",
")",
"if",
"axes",
":",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'ReduceSum'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"axes",
"=",
"axes",
",",
"keepdims",
"=",
"keepdims",
",",
"name",
"=",
"name",
")",
"else",
":",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'ReduceSum'",
",",
"inputs",
"=",
"input_nodes",
",",
"outputs",
"=",
"[",
"name",
"]",
",",
"keepdims",
"=",
"keepdims",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's sum operator attributes to onnx's ReduceSum operator
and return the created node. | [
"Map",
"MXNet",
"s",
"sum",
"operator",
"attributes",
"to",
"onnx",
"s",
"ReduceSum",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1701-L1729 |
23,641 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_hardsigmoid | def convert_hardsigmoid(node, **kwargs):
"""Map MXNet's hard_sigmoid operator attributes to onnx's HardSigmoid operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
alpha = float(attrs.get("alpha", 0.2))
beta = float(attrs.get("beta", 0.5))
node = onnx.helper.make_node(
'HardSigmoid',
input_nodes,
[name],
alpha=alpha,
beta=beta,
name=name
)
return [node] | python | def convert_hardsigmoid(node, **kwargs):
"""Map MXNet's hard_sigmoid operator attributes to onnx's HardSigmoid operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
alpha = float(attrs.get("alpha", 0.2))
beta = float(attrs.get("beta", 0.5))
node = onnx.helper.make_node(
'HardSigmoid',
input_nodes,
[name],
alpha=alpha,
beta=beta,
name=name
)
return [node] | [
"def",
"convert_hardsigmoid",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"# Converting to float32",
"alpha",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"alpha\"",
",",
"0.2",
")",
")",
"beta",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"beta\"",
",",
"0.5",
")",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'HardSigmoid'",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"alpha",
"=",
"alpha",
",",
"beta",
"=",
"beta",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's hard_sigmoid operator attributes to onnx's HardSigmoid operator
and return the created node. | [
"Map",
"MXNet",
"s",
"hard_sigmoid",
"operator",
"attributes",
"to",
"onnx",
"s",
"HardSigmoid",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1741-L1759 |
23,642 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_logsoftmax | def convert_logsoftmax(node, **kwargs):
"""Map MXNet's log_softmax operator attributes to onnx's LogSoftMax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to int
axis = int(attrs.get("axis", -1))
temp = attrs.get("temperature", 'None')
if temp != 'None':
raise AttributeError("LogSoftMax: ONNX supports only temperature=None")
node = onnx.helper.make_node(
'LogSoftmax',
input_nodes,
[name],
axis=axis,
name=name
)
return [node] | python | def convert_logsoftmax(node, **kwargs):
"""Map MXNet's log_softmax operator attributes to onnx's LogSoftMax operator
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to int
axis = int(attrs.get("axis", -1))
temp = attrs.get("temperature", 'None')
if temp != 'None':
raise AttributeError("LogSoftMax: ONNX supports only temperature=None")
node = onnx.helper.make_node(
'LogSoftmax',
input_nodes,
[name],
axis=axis,
name=name
)
return [node] | [
"def",
"convert_logsoftmax",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"# Converting to int",
"axis",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"-",
"1",
")",
")",
"temp",
"=",
"attrs",
".",
"get",
"(",
"\"temperature\"",
",",
"'None'",
")",
"if",
"temp",
"!=",
"'None'",
":",
"raise",
"AttributeError",
"(",
"\"LogSoftMax: ONNX supports only temperature=None\"",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'LogSoftmax'",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axis",
"=",
"axis",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's log_softmax operator attributes to onnx's LogSoftMax operator
and return the created node. | [
"Map",
"MXNet",
"s",
"log_softmax",
"operator",
"attributes",
"to",
"onnx",
"s",
"LogSoftMax",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1824-L1843 |
23,643 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_norm | def convert_norm(node, **kwargs):
"""Map MXNet's norm operator attributes to onnx's ReduceL1 and ReduceL2 operators
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
ord = int(attrs.get("ord", 2))
onnx_op_name = "ReduceL1" if ord == 1 else "ReduceL2"
if axes:
reduce_node = onnx.helper.make_node(
onnx_op_name,
input_nodes,
[name],
axes=axes,
keepdims=keepdims,
name=name
)
return [reduce_node]
else:
reduce_node = onnx.helper.make_node(
onnx_op_name,
input_nodes,
[name],
keepdims=keepdims,
name=name
)
return [reduce_node] | python | def convert_norm(node, **kwargs):
"""Map MXNet's norm operator attributes to onnx's ReduceL1 and ReduceL2 operators
and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
mx_axis = attrs.get("axis", None)
axes = convert_string_to_list(str(mx_axis)) if mx_axis else None
keepdims = get_boolean_attribute_value(attrs, "keepdims")
ord = int(attrs.get("ord", 2))
onnx_op_name = "ReduceL1" if ord == 1 else "ReduceL2"
if axes:
reduce_node = onnx.helper.make_node(
onnx_op_name,
input_nodes,
[name],
axes=axes,
keepdims=keepdims,
name=name
)
return [reduce_node]
else:
reduce_node = onnx.helper.make_node(
onnx_op_name,
input_nodes,
[name],
keepdims=keepdims,
name=name
)
return [reduce_node] | [
"def",
"convert_norm",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"mx_axis",
"=",
"attrs",
".",
"get",
"(",
"\"axis\"",
",",
"None",
")",
"axes",
"=",
"convert_string_to_list",
"(",
"str",
"(",
"mx_axis",
")",
")",
"if",
"mx_axis",
"else",
"None",
"keepdims",
"=",
"get_boolean_attribute_value",
"(",
"attrs",
",",
"\"keepdims\"",
")",
"ord",
"=",
"int",
"(",
"attrs",
".",
"get",
"(",
"\"ord\"",
",",
"2",
")",
")",
"onnx_op_name",
"=",
"\"ReduceL1\"",
"if",
"ord",
"==",
"1",
"else",
"\"ReduceL2\"",
"if",
"axes",
":",
"reduce_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"onnx_op_name",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"axes",
"=",
"axes",
",",
"keepdims",
"=",
"keepdims",
",",
"name",
"=",
"name",
")",
"return",
"[",
"reduce_node",
"]",
"else",
":",
"reduce_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"onnx_op_name",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"keepdims",
"=",
"keepdims",
",",
"name",
"=",
"name",
")",
"return",
"[",
"reduce_node",
"]"
] | Map MXNet's norm operator attributes to onnx's ReduceL1 and ReduceL2 operators
and return the created node. | [
"Map",
"MXNet",
"s",
"norm",
"operator",
"attributes",
"to",
"onnx",
"s",
"ReduceL1",
"and",
"ReduceL2",
"operators",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1846-L1878 |
23,644 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_multinomial | def convert_multinomial(node, **kwargs):
"""Map MXNet's multinomial operator attributes to onnx's
Multinomial operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get("dtype", 'int32'))]
sample_size = convert_string_to_list(attrs.get("shape", '1'))
if len(sample_size) < 2:
sample_size = sample_size[-1]
else:
raise AttributeError("ONNX currently supports integer sample_size only")
node = onnx.helper.make_node(
"Multinomial",
input_nodes,
[name],
dtype=dtype,
sample_size=sample_size,
name=name,
)
return [node] | python | def convert_multinomial(node, **kwargs):
"""Map MXNet's multinomial operator attributes to onnx's
Multinomial operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get("dtype", 'int32'))]
sample_size = convert_string_to_list(attrs.get("shape", '1'))
if len(sample_size) < 2:
sample_size = sample_size[-1]
else:
raise AttributeError("ONNX currently supports integer sample_size only")
node = onnx.helper.make_node(
"Multinomial",
input_nodes,
[name],
dtype=dtype,
sample_size=sample_size,
name=name,
)
return [node] | [
"def",
"convert_multinomial",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"dtype",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np",
".",
"dtype",
"(",
"attrs",
".",
"get",
"(",
"\"dtype\"",
",",
"'int32'",
")",
")",
"]",
"sample_size",
"=",
"convert_string_to_list",
"(",
"attrs",
".",
"get",
"(",
"\"shape\"",
",",
"'1'",
")",
")",
"if",
"len",
"(",
"sample_size",
")",
"<",
"2",
":",
"sample_size",
"=",
"sample_size",
"[",
"-",
"1",
"]",
"else",
":",
"raise",
"AttributeError",
"(",
"\"ONNX currently supports integer sample_size only\"",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Multinomial\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"dtype",
"=",
"dtype",
",",
"sample_size",
"=",
"sample_size",
",",
"name",
"=",
"name",
",",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's multinomial operator attributes to onnx's
Multinomial operator and return the created node. | [
"Map",
"MXNet",
"s",
"multinomial",
"operator",
"attributes",
"to",
"onnx",
"s",
"Multinomial",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1881-L1900 |
23,645 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_random_uniform | def convert_random_uniform(node, **kwargs):
"""Map MXNet's random_uniform operator attributes to onnx's RandomUniform
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
low = float(attrs.get("low", 0))
high = float(attrs.get("high", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get('dtype', 'float32'))]
node = onnx.helper.make_node(
'RandomUniform',
input_nodes,
[name],
low=low,
high=high,
dtype=dtype,
shape=shape,
name=name
)
return [node] | python | def convert_random_uniform(node, **kwargs):
"""Map MXNet's random_uniform operator attributes to onnx's RandomUniform
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
low = float(attrs.get("low", 0))
high = float(attrs.get("high", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get('dtype', 'float32'))]
node = onnx.helper.make_node(
'RandomUniform',
input_nodes,
[name],
low=low,
high=high,
dtype=dtype,
shape=shape,
name=name
)
return [node] | [
"def",
"convert_random_uniform",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"# Converting to float32",
"low",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"low\"",
",",
"0",
")",
")",
"high",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"high\"",
",",
"1.0",
")",
")",
"shape",
"=",
"convert_string_to_list",
"(",
"attrs",
".",
"get",
"(",
"'shape'",
",",
"'[]'",
")",
")",
"dtype",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np",
".",
"dtype",
"(",
"attrs",
".",
"get",
"(",
"'dtype'",
",",
"'float32'",
")",
")",
"]",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'RandomUniform'",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"low",
"=",
"low",
",",
"high",
"=",
"high",
",",
"dtype",
"=",
"dtype",
",",
"shape",
"=",
"shape",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's random_uniform operator attributes to onnx's RandomUniform
operator and return the created node. | [
"Map",
"MXNet",
"s",
"random_uniform",
"operator",
"attributes",
"to",
"onnx",
"s",
"RandomUniform",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1904-L1926 |
23,646 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_random_normal | def convert_random_normal(node, **kwargs):
"""Map MXNet's random_normal operator attributes to onnx's RandomNormal
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
mean = float(attrs.get("loc", 0))
scale = float(attrs.get("scale", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get('dtype', 'float32'))]
node = onnx.helper.make_node(
'RandomNormal',
input_nodes,
[name],
mean=mean,
scale=scale,
dtype=dtype,
shape=shape,
name=name
)
return [node] | python | def convert_random_normal(node, **kwargs):
"""Map MXNet's random_normal operator attributes to onnx's RandomNormal
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
# Converting to float32
mean = float(attrs.get("loc", 0))
scale = float(attrs.get("scale", 1.0))
shape = convert_string_to_list(attrs.get('shape', '[]'))
dtype = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype(attrs.get('dtype', 'float32'))]
node = onnx.helper.make_node(
'RandomNormal',
input_nodes,
[name],
mean=mean,
scale=scale,
dtype=dtype,
shape=shape,
name=name
)
return [node] | [
"def",
"convert_random_normal",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"# Converting to float32",
"mean",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"loc\"",
",",
"0",
")",
")",
"scale",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"scale\"",
",",
"1.0",
")",
")",
"shape",
"=",
"convert_string_to_list",
"(",
"attrs",
".",
"get",
"(",
"'shape'",
",",
"'[]'",
")",
")",
"dtype",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"np",
".",
"dtype",
"(",
"attrs",
".",
"get",
"(",
"'dtype'",
",",
"'float32'",
")",
")",
"]",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'RandomNormal'",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"mean",
"=",
"mean",
",",
"scale",
"=",
"scale",
",",
"dtype",
"=",
"dtype",
",",
"shape",
"=",
"shape",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's random_normal operator attributes to onnx's RandomNormal
operator and return the created node. | [
"Map",
"MXNet",
"s",
"random_normal",
"operator",
"attributes",
"to",
"onnx",
"s",
"RandomNormal",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1930-L1952 |
23,647 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_roipooling | def convert_roipooling(node, **kwargs):
"""Map MXNet's ROIPooling operator attributes to onnx's MaxRoiPool
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
pooled_shape = convert_string_to_list(attrs.get('pooled_size'))
scale = float(attrs.get("spatial_scale"))
node = onnx.helper.make_node(
'MaxRoiPool',
input_nodes,
[name],
pooled_shape=pooled_shape,
spatial_scale=scale,
name=name
)
return [node] | python | def convert_roipooling(node, **kwargs):
"""Map MXNet's ROIPooling operator attributes to onnx's MaxRoiPool
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
pooled_shape = convert_string_to_list(attrs.get('pooled_size'))
scale = float(attrs.get("spatial_scale"))
node = onnx.helper.make_node(
'MaxRoiPool',
input_nodes,
[name],
pooled_shape=pooled_shape,
spatial_scale=scale,
name=name
)
return [node] | [
"def",
"convert_roipooling",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"pooled_shape",
"=",
"convert_string_to_list",
"(",
"attrs",
".",
"get",
"(",
"'pooled_size'",
")",
")",
"scale",
"=",
"float",
"(",
"attrs",
".",
"get",
"(",
"\"spatial_scale\"",
")",
")",
"node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"'MaxRoiPool'",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"pooled_shape",
"=",
"pooled_shape",
",",
"spatial_scale",
"=",
"scale",
",",
"name",
"=",
"name",
")",
"return",
"[",
"node",
"]"
] | Map MXNet's ROIPooling operator attributes to onnx's MaxRoiPool
operator and return the created node. | [
"Map",
"MXNet",
"s",
"ROIPooling",
"operator",
"attributes",
"to",
"onnx",
"s",
"MaxRoiPool",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1956-L1973 |
23,648 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_tile | def convert_tile(node, **kwargs):
"""Map MXNet's Tile operator attributes to onnx's Tile
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
reps_list = convert_string_to_list(attrs["reps"])
initializer = kwargs["initializer"]
reps_shape_np = np.array(reps_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[reps_shape_np.dtype]
dims = np.shape(reps_shape_np)
output_shape_name = "reps_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=reps_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
tile_node = onnx.helper.make_node(
"Tile",
input_nodes,
[name],
name=name
)
return [tensor_node, tile_node] | python | def convert_tile(node, **kwargs):
"""Map MXNet's Tile operator attributes to onnx's Tile
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
reps_list = convert_string_to_list(attrs["reps"])
initializer = kwargs["initializer"]
reps_shape_np = np.array(reps_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[reps_shape_np.dtype]
dims = np.shape(reps_shape_np)
output_shape_name = "reps_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=reps_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
tile_node = onnx.helper.make_node(
"Tile",
input_nodes,
[name],
name=name
)
return [tensor_node, tile_node] | [
"def",
"convert_tile",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"reps_list",
"=",
"convert_string_to_list",
"(",
"attrs",
"[",
"\"reps\"",
"]",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"reps_shape_np",
"=",
"np",
".",
"array",
"(",
"reps_list",
",",
"dtype",
"=",
"'int64'",
")",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"reps_shape_np",
".",
"dtype",
"]",
"dims",
"=",
"np",
".",
"shape",
"(",
"reps_shape_np",
")",
"output_shape_name",
"=",
"\"reps_attr_tensor\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"output_shape_name",
",",
"data_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"output_shape_name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"reps_list",
",",
"raw",
"=",
"False",
",",
")",
")",
"input_nodes",
".",
"append",
"(",
"output_shape_name",
")",
"tile_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Tile\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"tensor_node",
",",
"tile_node",
"]"
] | Map MXNet's Tile operator attributes to onnx's Tile
operator and return the created node. | [
"Map",
"MXNet",
"s",
"Tile",
"operator",
"attributes",
"to",
"onnx",
"s",
"Tile",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L1977-L2011 |
23,649 | apache/incubator-mxnet | python/mxnet/contrib/onnx/mx2onnx/_op_translations.py | convert_broadcast_to | def convert_broadcast_to(node, **kwargs):
"""Map MXNet's broadcast_to operator attributes to onnx's Expand
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[output_shape_np.dtype]
dims = np.shape(output_shape_np)
output_shape_name = "expand_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=shape_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
expand_node = onnx.helper.make_node(
"Expand",
input_nodes,
[name],
name=name
)
return [tensor_node, expand_node] | python | def convert_broadcast_to(node, **kwargs):
"""Map MXNet's broadcast_to operator attributes to onnx's Expand
operator and return the created node.
"""
name, input_nodes, attrs = get_inputs(node, kwargs)
shape_list = convert_string_to_list(attrs["shape"])
initializer = kwargs["initializer"]
output_shape_np = np.array(shape_list, dtype='int64')
data_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[output_shape_np.dtype]
dims = np.shape(output_shape_np)
output_shape_name = "expand_attr_tensor" + str(kwargs["idx"])
tensor_node = onnx.helper.make_tensor_value_info(output_shape_name, data_type, dims)
initializer.append(
onnx.helper.make_tensor(
name=output_shape_name,
data_type=data_type,
dims=dims,
vals=shape_list,
raw=False,
)
)
input_nodes.append(output_shape_name)
expand_node = onnx.helper.make_node(
"Expand",
input_nodes,
[name],
name=name
)
return [tensor_node, expand_node] | [
"def",
"convert_broadcast_to",
"(",
"node",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
",",
"input_nodes",
",",
"attrs",
"=",
"get_inputs",
"(",
"node",
",",
"kwargs",
")",
"shape_list",
"=",
"convert_string_to_list",
"(",
"attrs",
"[",
"\"shape\"",
"]",
")",
"initializer",
"=",
"kwargs",
"[",
"\"initializer\"",
"]",
"output_shape_np",
"=",
"np",
".",
"array",
"(",
"shape_list",
",",
"dtype",
"=",
"'int64'",
")",
"data_type",
"=",
"onnx",
".",
"mapping",
".",
"NP_TYPE_TO_TENSOR_TYPE",
"[",
"output_shape_np",
".",
"dtype",
"]",
"dims",
"=",
"np",
".",
"shape",
"(",
"output_shape_np",
")",
"output_shape_name",
"=",
"\"expand_attr_tensor\"",
"+",
"str",
"(",
"kwargs",
"[",
"\"idx\"",
"]",
")",
"tensor_node",
"=",
"onnx",
".",
"helper",
".",
"make_tensor_value_info",
"(",
"output_shape_name",
",",
"data_type",
",",
"dims",
")",
"initializer",
".",
"append",
"(",
"onnx",
".",
"helper",
".",
"make_tensor",
"(",
"name",
"=",
"output_shape_name",
",",
"data_type",
"=",
"data_type",
",",
"dims",
"=",
"dims",
",",
"vals",
"=",
"shape_list",
",",
"raw",
"=",
"False",
",",
")",
")",
"input_nodes",
".",
"append",
"(",
"output_shape_name",
")",
"expand_node",
"=",
"onnx",
".",
"helper",
".",
"make_node",
"(",
"\"Expand\"",
",",
"input_nodes",
",",
"[",
"name",
"]",
",",
"name",
"=",
"name",
")",
"return",
"[",
"tensor_node",
",",
"expand_node",
"]"
] | Map MXNet's broadcast_to operator attributes to onnx's Expand
operator and return the created node. | [
"Map",
"MXNet",
"s",
"broadcast_to",
"operator",
"attributes",
"to",
"onnx",
"s",
"Expand",
"operator",
"and",
"return",
"the",
"created",
"node",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/mx2onnx/_op_translations.py#L2015-L2049 |
23,650 | apache/incubator-mxnet | example/reinforcement-learning/dqn/base.py | Base.exe | def exe(self):
"""Get the current executor
Returns
-------
exe : mxnet.executor.Executor
"""
return self._buckets[self.curr_bucket_key]['exe'][tuple(self.data_shapes.items())] | python | def exe(self):
"""Get the current executor
Returns
-------
exe : mxnet.executor.Executor
"""
return self._buckets[self.curr_bucket_key]['exe'][tuple(self.data_shapes.items())] | [
"def",
"exe",
"(",
"self",
")",
":",
"return",
"self",
".",
"_buckets",
"[",
"self",
".",
"curr_bucket_key",
"]",
"[",
"'exe'",
"]",
"[",
"tuple",
"(",
"self",
".",
"data_shapes",
".",
"items",
"(",
")",
")",
"]"
] | Get the current executor
Returns
-------
exe : mxnet.executor.Executor | [
"Get",
"the",
"current",
"executor"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/reinforcement-learning/dqn/base.py#L80-L87 |
23,651 | apache/incubator-mxnet | example/reinforcement-learning/dqn/base.py | Base.compute_internal | def compute_internal(self, sym_name, bucket_kwargs=None, **arg_dict):
"""
View the internal symbols using the forward function.
:param sym_name:
:param bucket_kwargs:
:param input_dict:
:return:
"""
data_shapes = {k: v.shape for k, v in arg_dict.items()}
self.switch_bucket(bucket_kwargs=bucket_kwargs,
data_shapes=data_shapes)
internal_sym = self.sym.get_internals()[sym_name]
data_inputs = {k: mx.nd.empty(v, ctx=self.ctx)
for k, v in self.data_shapes.items()
if k in internal_sym.list_arguments()}
params = {k: v for k, v in self.params.items() if
k in internal_sym.list_arguments()}
aux_states = {k: v for k, v in self.aux_states.items()
if k in internal_sym.list_auxiliary_states()}
exe = internal_sym.bind(ctx=self.ctx,
args=dict(params, **data_inputs),
args_grad=None,
grad_req='null',
aux_states=aux_states,
shared_exec=self.exe)
for k, v in arg_dict.items():
exe.arg_dict[k][:] = v
exe.forward(is_train=False)
assert 1 == len(exe.outputs)
for output in exe.outputs:
output.wait_to_read()
return exe.outputs[0] | python | def compute_internal(self, sym_name, bucket_kwargs=None, **arg_dict):
"""
View the internal symbols using the forward function.
:param sym_name:
:param bucket_kwargs:
:param input_dict:
:return:
"""
data_shapes = {k: v.shape for k, v in arg_dict.items()}
self.switch_bucket(bucket_kwargs=bucket_kwargs,
data_shapes=data_shapes)
internal_sym = self.sym.get_internals()[sym_name]
data_inputs = {k: mx.nd.empty(v, ctx=self.ctx)
for k, v in self.data_shapes.items()
if k in internal_sym.list_arguments()}
params = {k: v for k, v in self.params.items() if
k in internal_sym.list_arguments()}
aux_states = {k: v for k, v in self.aux_states.items()
if k in internal_sym.list_auxiliary_states()}
exe = internal_sym.bind(ctx=self.ctx,
args=dict(params, **data_inputs),
args_grad=None,
grad_req='null',
aux_states=aux_states,
shared_exec=self.exe)
for k, v in arg_dict.items():
exe.arg_dict[k][:] = v
exe.forward(is_train=False)
assert 1 == len(exe.outputs)
for output in exe.outputs:
output.wait_to_read()
return exe.outputs[0] | [
"def",
"compute_internal",
"(",
"self",
",",
"sym_name",
",",
"bucket_kwargs",
"=",
"None",
",",
"*",
"*",
"arg_dict",
")",
":",
"data_shapes",
"=",
"{",
"k",
":",
"v",
".",
"shape",
"for",
"k",
",",
"v",
"in",
"arg_dict",
".",
"items",
"(",
")",
"}",
"self",
".",
"switch_bucket",
"(",
"bucket_kwargs",
"=",
"bucket_kwargs",
",",
"data_shapes",
"=",
"data_shapes",
")",
"internal_sym",
"=",
"self",
".",
"sym",
".",
"get_internals",
"(",
")",
"[",
"sym_name",
"]",
"data_inputs",
"=",
"{",
"k",
":",
"mx",
".",
"nd",
".",
"empty",
"(",
"v",
",",
"ctx",
"=",
"self",
".",
"ctx",
")",
"for",
"k",
",",
"v",
"in",
"self",
".",
"data_shapes",
".",
"items",
"(",
")",
"if",
"k",
"in",
"internal_sym",
".",
"list_arguments",
"(",
")",
"}",
"params",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"self",
".",
"params",
".",
"items",
"(",
")",
"if",
"k",
"in",
"internal_sym",
".",
"list_arguments",
"(",
")",
"}",
"aux_states",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"self",
".",
"aux_states",
".",
"items",
"(",
")",
"if",
"k",
"in",
"internal_sym",
".",
"list_auxiliary_states",
"(",
")",
"}",
"exe",
"=",
"internal_sym",
".",
"bind",
"(",
"ctx",
"=",
"self",
".",
"ctx",
",",
"args",
"=",
"dict",
"(",
"params",
",",
"*",
"*",
"data_inputs",
")",
",",
"args_grad",
"=",
"None",
",",
"grad_req",
"=",
"'null'",
",",
"aux_states",
"=",
"aux_states",
",",
"shared_exec",
"=",
"self",
".",
"exe",
")",
"for",
"k",
",",
"v",
"in",
"arg_dict",
".",
"items",
"(",
")",
":",
"exe",
".",
"arg_dict",
"[",
"k",
"]",
"[",
":",
"]",
"=",
"v",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"False",
")",
"assert",
"1",
"==",
"len",
"(",
"exe",
".",
"outputs",
")",
"for",
"output",
"in",
"exe",
".",
"outputs",
":",
"output",
".",
"wait_to_read",
"(",
")",
"return",
"exe",
".",
"outputs",
"[",
"0",
"]"
] | View the internal symbols using the forward function.
:param sym_name:
:param bucket_kwargs:
:param input_dict:
:return: | [
"View",
"the",
"internal",
"symbols",
"using",
"the",
"forward",
"function",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/reinforcement-learning/dqn/base.py#L190-L222 |
23,652 | apache/incubator-mxnet | example/fcn-xs/init_fcnxs.py | init_from_fcnxs | def init_from_fcnxs(ctx, fcnxs_symbol, fcnxs_args_from, fcnxs_auxs_from):
""" use zero initialization for better convergence, because it tends to oputut 0,
and the label 0 stands for background, which may occupy most size of one image.
"""
fcnxs_args = fcnxs_args_from.copy()
fcnxs_auxs = fcnxs_auxs_from.copy()
for k,v in fcnxs_args.items():
if(v.context != ctx):
fcnxs_args[k] = mx.nd.zeros(v.shape, ctx)
v.copyto(fcnxs_args[k])
for k,v in fcnxs_auxs.items():
if(v.context != ctx):
fcnxs_auxs[k] = mx.nd.zeros(v.shape, ctx)
v.copyto(fcnxs_auxs[k])
data_shape=(1,3,500,500)
arg_names = fcnxs_symbol.list_arguments()
arg_shapes, _, _ = fcnxs_symbol.infer_shape(data=data_shape)
rest_params = {}
deconv_params = {}
# this is fcn8s init from fcn16s
if 'score_pool3_weight' in arg_names:
rest_params = dict([(x[0], mx.nd.zeros(x[1], ctx)) for x in zip(arg_names, arg_shapes)
if x[0] in ['score_pool3_bias', 'score_pool3_weight']])
deconv_params = dict([(x[0], x[1]) for x in zip(arg_names, arg_shapes) if x[0] \
in ["bigscore_weight", 'score4_weight']])
# this is fcn16s init from fcn32s
elif 'score_pool4_weight' in arg_names:
rest_params = dict([(x[0], mx.nd.zeros(x[1], ctx)) for x in zip(arg_names, arg_shapes)
if x[0] in ['score_pool4_weight', 'score_pool4_bias']])
deconv_params = dict([(x[0], x[1]) for x in zip(arg_names, arg_shapes) if x[0] \
in ["bigscore_weight", 'score2_weight']])
# this is fcn32s init
else:
logging.error("you are init the fcn32s model, so you should use init_from_vgg16()")
sys.exit()
fcnxs_args.update(rest_params)
for k, v in deconv_params.items():
filt = upsample_filt(v[3])
initw = np.zeros(v)
initw[range(v[0]), range(v[1]), :, :] = filt # becareful here is the slice assing
fcnxs_args[k] = mx.nd.array(initw, ctx)
return fcnxs_args, fcnxs_auxs | python | def init_from_fcnxs(ctx, fcnxs_symbol, fcnxs_args_from, fcnxs_auxs_from):
""" use zero initialization for better convergence, because it tends to oputut 0,
and the label 0 stands for background, which may occupy most size of one image.
"""
fcnxs_args = fcnxs_args_from.copy()
fcnxs_auxs = fcnxs_auxs_from.copy()
for k,v in fcnxs_args.items():
if(v.context != ctx):
fcnxs_args[k] = mx.nd.zeros(v.shape, ctx)
v.copyto(fcnxs_args[k])
for k,v in fcnxs_auxs.items():
if(v.context != ctx):
fcnxs_auxs[k] = mx.nd.zeros(v.shape, ctx)
v.copyto(fcnxs_auxs[k])
data_shape=(1,3,500,500)
arg_names = fcnxs_symbol.list_arguments()
arg_shapes, _, _ = fcnxs_symbol.infer_shape(data=data_shape)
rest_params = {}
deconv_params = {}
# this is fcn8s init from fcn16s
if 'score_pool3_weight' in arg_names:
rest_params = dict([(x[0], mx.nd.zeros(x[1], ctx)) for x in zip(arg_names, arg_shapes)
if x[0] in ['score_pool3_bias', 'score_pool3_weight']])
deconv_params = dict([(x[0], x[1]) for x in zip(arg_names, arg_shapes) if x[0] \
in ["bigscore_weight", 'score4_weight']])
# this is fcn16s init from fcn32s
elif 'score_pool4_weight' in arg_names:
rest_params = dict([(x[0], mx.nd.zeros(x[1], ctx)) for x in zip(arg_names, arg_shapes)
if x[0] in ['score_pool4_weight', 'score_pool4_bias']])
deconv_params = dict([(x[0], x[1]) for x in zip(arg_names, arg_shapes) if x[0] \
in ["bigscore_weight", 'score2_weight']])
# this is fcn32s init
else:
logging.error("you are init the fcn32s model, so you should use init_from_vgg16()")
sys.exit()
fcnxs_args.update(rest_params)
for k, v in deconv_params.items():
filt = upsample_filt(v[3])
initw = np.zeros(v)
initw[range(v[0]), range(v[1]), :, :] = filt # becareful here is the slice assing
fcnxs_args[k] = mx.nd.array(initw, ctx)
return fcnxs_args, fcnxs_auxs | [
"def",
"init_from_fcnxs",
"(",
"ctx",
",",
"fcnxs_symbol",
",",
"fcnxs_args_from",
",",
"fcnxs_auxs_from",
")",
":",
"fcnxs_args",
"=",
"fcnxs_args_from",
".",
"copy",
"(",
")",
"fcnxs_auxs",
"=",
"fcnxs_auxs_from",
".",
"copy",
"(",
")",
"for",
"k",
",",
"v",
"in",
"fcnxs_args",
".",
"items",
"(",
")",
":",
"if",
"(",
"v",
".",
"context",
"!=",
"ctx",
")",
":",
"fcnxs_args",
"[",
"k",
"]",
"=",
"mx",
".",
"nd",
".",
"zeros",
"(",
"v",
".",
"shape",
",",
"ctx",
")",
"v",
".",
"copyto",
"(",
"fcnxs_args",
"[",
"k",
"]",
")",
"for",
"k",
",",
"v",
"in",
"fcnxs_auxs",
".",
"items",
"(",
")",
":",
"if",
"(",
"v",
".",
"context",
"!=",
"ctx",
")",
":",
"fcnxs_auxs",
"[",
"k",
"]",
"=",
"mx",
".",
"nd",
".",
"zeros",
"(",
"v",
".",
"shape",
",",
"ctx",
")",
"v",
".",
"copyto",
"(",
"fcnxs_auxs",
"[",
"k",
"]",
")",
"data_shape",
"=",
"(",
"1",
",",
"3",
",",
"500",
",",
"500",
")",
"arg_names",
"=",
"fcnxs_symbol",
".",
"list_arguments",
"(",
")",
"arg_shapes",
",",
"_",
",",
"_",
"=",
"fcnxs_symbol",
".",
"infer_shape",
"(",
"data",
"=",
"data_shape",
")",
"rest_params",
"=",
"{",
"}",
"deconv_params",
"=",
"{",
"}",
"# this is fcn8s init from fcn16s",
"if",
"'score_pool3_weight'",
"in",
"arg_names",
":",
"rest_params",
"=",
"dict",
"(",
"[",
"(",
"x",
"[",
"0",
"]",
",",
"mx",
".",
"nd",
".",
"zeros",
"(",
"x",
"[",
"1",
"]",
",",
"ctx",
")",
")",
"for",
"x",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
"if",
"x",
"[",
"0",
"]",
"in",
"[",
"'score_pool3_bias'",
",",
"'score_pool3_weight'",
"]",
"]",
")",
"deconv_params",
"=",
"dict",
"(",
"[",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
")",
"for",
"x",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
"if",
"x",
"[",
"0",
"]",
"in",
"[",
"\"bigscore_weight\"",
",",
"'score4_weight'",
"]",
"]",
")",
"# this is fcn16s init from fcn32s",
"elif",
"'score_pool4_weight'",
"in",
"arg_names",
":",
"rest_params",
"=",
"dict",
"(",
"[",
"(",
"x",
"[",
"0",
"]",
",",
"mx",
".",
"nd",
".",
"zeros",
"(",
"x",
"[",
"1",
"]",
",",
"ctx",
")",
")",
"for",
"x",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
"if",
"x",
"[",
"0",
"]",
"in",
"[",
"'score_pool4_weight'",
",",
"'score_pool4_bias'",
"]",
"]",
")",
"deconv_params",
"=",
"dict",
"(",
"[",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
")",
"for",
"x",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
"if",
"x",
"[",
"0",
"]",
"in",
"[",
"\"bigscore_weight\"",
",",
"'score2_weight'",
"]",
"]",
")",
"# this is fcn32s init",
"else",
":",
"logging",
".",
"error",
"(",
"\"you are init the fcn32s model, so you should use init_from_vgg16()\"",
")",
"sys",
".",
"exit",
"(",
")",
"fcnxs_args",
".",
"update",
"(",
"rest_params",
")",
"for",
"k",
",",
"v",
"in",
"deconv_params",
".",
"items",
"(",
")",
":",
"filt",
"=",
"upsample_filt",
"(",
"v",
"[",
"3",
"]",
")",
"initw",
"=",
"np",
".",
"zeros",
"(",
"v",
")",
"initw",
"[",
"range",
"(",
"v",
"[",
"0",
"]",
")",
",",
"range",
"(",
"v",
"[",
"1",
"]",
")",
",",
":",
",",
":",
"]",
"=",
"filt",
"# becareful here is the slice assing",
"fcnxs_args",
"[",
"k",
"]",
"=",
"mx",
".",
"nd",
".",
"array",
"(",
"initw",
",",
"ctx",
")",
"return",
"fcnxs_args",
",",
"fcnxs_auxs"
] | use zero initialization for better convergence, because it tends to oputut 0,
and the label 0 stands for background, which may occupy most size of one image. | [
"use",
"zero",
"initialization",
"for",
"better",
"convergence",
"because",
"it",
"tends",
"to",
"oputut",
"0",
"and",
"the",
"label",
"0",
"stands",
"for",
"background",
"which",
"may",
"occupy",
"most",
"size",
"of",
"one",
"image",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/fcn-xs/init_fcnxs.py#L65-L106 |
23,653 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | var | def var(name, attr=None, shape=None, lr_mult=None, wd_mult=None, dtype=None,
init=None, stype=None, **kwargs):
"""Creates a symbolic variable with specified name.
Example
-------
>>> data = mx.sym.Variable('data', attr={'a': 'b'})
>>> data
<Symbol data>
>>> csr_data = mx.sym.Variable('csr_data', stype='csr')
>>> csr_data
<Symbol csr_data>
>>> row_sparse_weight = mx.sym.Variable('weight', stype='row_sparse')
>>> row_sparse_weight
<Symbol weight>
Parameters
----------
name : str
Variable name.
attr : Dict of strings
Additional attributes to set on the variable. Format {string : string}.
shape : tuple
The shape of a variable. If specified, this will be used during the shape inference.
If one has specified a different shape for this variable using
a keyword argument when calling shape inference, this shape information will be ignored.
lr_mult : float
The learning rate multiplier for input variable.
wd_mult : float
Weight decay multiplier for input variable.
dtype : str or numpy.dtype
The dtype for input variable. If not specified, this value will be inferred.
init : initializer (mxnet.init.*)
Initializer for this variable to (optionally) override the default initializer.
stype : str
The storage type of the variable, such as 'row_sparse', 'csr', 'default', etc
kwargs : Additional attribute variables
Additional attributes must start and end with double underscores.
Returns
-------
variable : Symbol
A symbol corresponding to an input to the computation graph.
"""
if not isinstance(name, string_types):
raise TypeError('Expect a string for variable `name`')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateVariable(c_str(name), ctypes.byref(handle)))
ret = Symbol(handle)
if not hasattr(AttrScope._current, "value"):
AttrScope._current.value = AttrScope()
attr = AttrScope._current.value.get(attr)
attr = {} if attr is None else attr
if shape is not None:
attr['__shape__'] = str(shape)
if lr_mult is not None:
attr['__lr_mult__'] = str(lr_mult)
if wd_mult is not None:
attr['__wd_mult__'] = str(wd_mult)
if dtype is not None:
attr['__dtype__'] = str(_DTYPE_NP_TO_MX[_numpy.dtype(dtype).type])
if init is not None:
if not isinstance(init, string_types):
init = init.dumps()
attr['__init__'] = init
if stype is not None:
attr['__storage_type__'] = str(_STORAGE_TYPE_STR_TO_ID[stype])
for k, v in kwargs.items():
if k.startswith('__') and k.endswith('__'):
attr[k] = str(v)
else:
raise ValueError('Attribute name=%s is not supported.'
' Additional attributes must start and end with double underscores,'
' e.g, __yourattr__' % k)
ret._set_attr(**attr)
return ret | python | def var(name, attr=None, shape=None, lr_mult=None, wd_mult=None, dtype=None,
init=None, stype=None, **kwargs):
"""Creates a symbolic variable with specified name.
Example
-------
>>> data = mx.sym.Variable('data', attr={'a': 'b'})
>>> data
<Symbol data>
>>> csr_data = mx.sym.Variable('csr_data', stype='csr')
>>> csr_data
<Symbol csr_data>
>>> row_sparse_weight = mx.sym.Variable('weight', stype='row_sparse')
>>> row_sparse_weight
<Symbol weight>
Parameters
----------
name : str
Variable name.
attr : Dict of strings
Additional attributes to set on the variable. Format {string : string}.
shape : tuple
The shape of a variable. If specified, this will be used during the shape inference.
If one has specified a different shape for this variable using
a keyword argument when calling shape inference, this shape information will be ignored.
lr_mult : float
The learning rate multiplier for input variable.
wd_mult : float
Weight decay multiplier for input variable.
dtype : str or numpy.dtype
The dtype for input variable. If not specified, this value will be inferred.
init : initializer (mxnet.init.*)
Initializer for this variable to (optionally) override the default initializer.
stype : str
The storage type of the variable, such as 'row_sparse', 'csr', 'default', etc
kwargs : Additional attribute variables
Additional attributes must start and end with double underscores.
Returns
-------
variable : Symbol
A symbol corresponding to an input to the computation graph.
"""
if not isinstance(name, string_types):
raise TypeError('Expect a string for variable `name`')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateVariable(c_str(name), ctypes.byref(handle)))
ret = Symbol(handle)
if not hasattr(AttrScope._current, "value"):
AttrScope._current.value = AttrScope()
attr = AttrScope._current.value.get(attr)
attr = {} if attr is None else attr
if shape is not None:
attr['__shape__'] = str(shape)
if lr_mult is not None:
attr['__lr_mult__'] = str(lr_mult)
if wd_mult is not None:
attr['__wd_mult__'] = str(wd_mult)
if dtype is not None:
attr['__dtype__'] = str(_DTYPE_NP_TO_MX[_numpy.dtype(dtype).type])
if init is not None:
if not isinstance(init, string_types):
init = init.dumps()
attr['__init__'] = init
if stype is not None:
attr['__storage_type__'] = str(_STORAGE_TYPE_STR_TO_ID[stype])
for k, v in kwargs.items():
if k.startswith('__') and k.endswith('__'):
attr[k] = str(v)
else:
raise ValueError('Attribute name=%s is not supported.'
' Additional attributes must start and end with double underscores,'
' e.g, __yourattr__' % k)
ret._set_attr(**attr)
return ret | [
"def",
"var",
"(",
"name",
",",
"attr",
"=",
"None",
",",
"shape",
"=",
"None",
",",
"lr_mult",
"=",
"None",
",",
"wd_mult",
"=",
"None",
",",
"dtype",
"=",
"None",
",",
"init",
"=",
"None",
",",
"stype",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"isinstance",
"(",
"name",
",",
"string_types",
")",
":",
"raise",
"TypeError",
"(",
"'Expect a string for variable `name`'",
")",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolCreateVariable",
"(",
"c_str",
"(",
"name",
")",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"ret",
"=",
"Symbol",
"(",
"handle",
")",
"if",
"not",
"hasattr",
"(",
"AttrScope",
".",
"_current",
",",
"\"value\"",
")",
":",
"AttrScope",
".",
"_current",
".",
"value",
"=",
"AttrScope",
"(",
")",
"attr",
"=",
"AttrScope",
".",
"_current",
".",
"value",
".",
"get",
"(",
"attr",
")",
"attr",
"=",
"{",
"}",
"if",
"attr",
"is",
"None",
"else",
"attr",
"if",
"shape",
"is",
"not",
"None",
":",
"attr",
"[",
"'__shape__'",
"]",
"=",
"str",
"(",
"shape",
")",
"if",
"lr_mult",
"is",
"not",
"None",
":",
"attr",
"[",
"'__lr_mult__'",
"]",
"=",
"str",
"(",
"lr_mult",
")",
"if",
"wd_mult",
"is",
"not",
"None",
":",
"attr",
"[",
"'__wd_mult__'",
"]",
"=",
"str",
"(",
"wd_mult",
")",
"if",
"dtype",
"is",
"not",
"None",
":",
"attr",
"[",
"'__dtype__'",
"]",
"=",
"str",
"(",
"_DTYPE_NP_TO_MX",
"[",
"_numpy",
".",
"dtype",
"(",
"dtype",
")",
".",
"type",
"]",
")",
"if",
"init",
"is",
"not",
"None",
":",
"if",
"not",
"isinstance",
"(",
"init",
",",
"string_types",
")",
":",
"init",
"=",
"init",
".",
"dumps",
"(",
")",
"attr",
"[",
"'__init__'",
"]",
"=",
"init",
"if",
"stype",
"is",
"not",
"None",
":",
"attr",
"[",
"'__storage_type__'",
"]",
"=",
"str",
"(",
"_STORAGE_TYPE_STR_TO_ID",
"[",
"stype",
"]",
")",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"k",
".",
"startswith",
"(",
"'__'",
")",
"and",
"k",
".",
"endswith",
"(",
"'__'",
")",
":",
"attr",
"[",
"k",
"]",
"=",
"str",
"(",
"v",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Attribute name=%s is not supported.'",
"' Additional attributes must start and end with double underscores,'",
"' e.g, __yourattr__'",
"%",
"k",
")",
"ret",
".",
"_set_attr",
"(",
"*",
"*",
"attr",
")",
"return",
"ret"
] | Creates a symbolic variable with specified name.
Example
-------
>>> data = mx.sym.Variable('data', attr={'a': 'b'})
>>> data
<Symbol data>
>>> csr_data = mx.sym.Variable('csr_data', stype='csr')
>>> csr_data
<Symbol csr_data>
>>> row_sparse_weight = mx.sym.Variable('weight', stype='row_sparse')
>>> row_sparse_weight
<Symbol weight>
Parameters
----------
name : str
Variable name.
attr : Dict of strings
Additional attributes to set on the variable. Format {string : string}.
shape : tuple
The shape of a variable. If specified, this will be used during the shape inference.
If one has specified a different shape for this variable using
a keyword argument when calling shape inference, this shape information will be ignored.
lr_mult : float
The learning rate multiplier for input variable.
wd_mult : float
Weight decay multiplier for input variable.
dtype : str or numpy.dtype
The dtype for input variable. If not specified, this value will be inferred.
init : initializer (mxnet.init.*)
Initializer for this variable to (optionally) override the default initializer.
stype : str
The storage type of the variable, such as 'row_sparse', 'csr', 'default', etc
kwargs : Additional attribute variables
Additional attributes must start and end with double underscores.
Returns
-------
variable : Symbol
A symbol corresponding to an input to the computation graph. | [
"Creates",
"a",
"symbolic",
"variable",
"with",
"specified",
"name",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2574-L2649 |
23,654 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Group | def Group(symbols):
"""Creates a symbol that contains a collection of other symbols, grouped together.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> mx.sym.Group([a,b])
<Symbol Grouped>
Parameters
----------
symbols : list
List of symbols to be grouped.
Returns
-------
sym : Symbol
A group symbol.
"""
if not symbols or any(not isinstance(sym, Symbol) for sym in symbols):
raise TypeError('Expected a list of symbols as input')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateGroup(
mx_uint(len(symbols)),
c_handle_array(symbols), ctypes.byref(handle)))
return Symbol(handle) | python | def Group(symbols):
"""Creates a symbol that contains a collection of other symbols, grouped together.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> mx.sym.Group([a,b])
<Symbol Grouped>
Parameters
----------
symbols : list
List of symbols to be grouped.
Returns
-------
sym : Symbol
A group symbol.
"""
if not symbols or any(not isinstance(sym, Symbol) for sym in symbols):
raise TypeError('Expected a list of symbols as input')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateGroup(
mx_uint(len(symbols)),
c_handle_array(symbols), ctypes.byref(handle)))
return Symbol(handle) | [
"def",
"Group",
"(",
"symbols",
")",
":",
"if",
"not",
"symbols",
"or",
"any",
"(",
"not",
"isinstance",
"(",
"sym",
",",
"Symbol",
")",
"for",
"sym",
"in",
"symbols",
")",
":",
"raise",
"TypeError",
"(",
"'Expected a list of symbols as input'",
")",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolCreateGroup",
"(",
"mx_uint",
"(",
"len",
"(",
"symbols",
")",
")",
",",
"c_handle_array",
"(",
"symbols",
")",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"return",
"Symbol",
"(",
"handle",
")"
] | Creates a symbol that contains a collection of other symbols, grouped together.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> mx.sym.Group([a,b])
<Symbol Grouped>
Parameters
----------
symbols : list
List of symbols to be grouped.
Returns
-------
sym : Symbol
A group symbol. | [
"Creates",
"a",
"symbol",
"that",
"contains",
"a",
"collection",
"of",
"other",
"symbols",
"grouped",
"together",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2656-L2682 |
23,655 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | load | def load(fname):
"""Loads symbol from a JSON file.
You can also use pickle to do the job if you only work on python.
The advantage of load/save is the file is language agnostic.
This means the file saved using save can be loaded by other language binding of mxnet.
You also get the benefit being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file, examples:
- `s3://my-bucket/path/my-s3-symbol`
- `hdfs://my-bucket/path/my-hdfs-symbol`
- `/path-to/my-local-symbol`
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.save : Used to save symbol into file.
"""
if not isinstance(fname, string_types):
raise TypeError('fname need to be string')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateFromFile(c_str(fname), ctypes.byref(handle)))
return Symbol(handle) | python | def load(fname):
"""Loads symbol from a JSON file.
You can also use pickle to do the job if you only work on python.
The advantage of load/save is the file is language agnostic.
This means the file saved using save can be loaded by other language binding of mxnet.
You also get the benefit being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file, examples:
- `s3://my-bucket/path/my-s3-symbol`
- `hdfs://my-bucket/path/my-hdfs-symbol`
- `/path-to/my-local-symbol`
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.save : Used to save symbol into file.
"""
if not isinstance(fname, string_types):
raise TypeError('fname need to be string')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateFromFile(c_str(fname), ctypes.byref(handle)))
return Symbol(handle) | [
"def",
"load",
"(",
"fname",
")",
":",
"if",
"not",
"isinstance",
"(",
"fname",
",",
"string_types",
")",
":",
"raise",
"TypeError",
"(",
"'fname need to be string'",
")",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolCreateFromFile",
"(",
"c_str",
"(",
"fname",
")",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"return",
"Symbol",
"(",
"handle",
")"
] | Loads symbol from a JSON file.
You can also use pickle to do the job if you only work on python.
The advantage of load/save is the file is language agnostic.
This means the file saved using save can be loaded by other language binding of mxnet.
You also get the benefit being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file, examples:
- `s3://my-bucket/path/my-s3-symbol`
- `hdfs://my-bucket/path/my-hdfs-symbol`
- `/path-to/my-local-symbol`
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.save : Used to save symbol into file. | [
"Loads",
"symbol",
"from",
"a",
"JSON",
"file",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2685-L2715 |
23,656 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | load_json | def load_json(json_str):
"""Loads symbol from json string.
Parameters
----------
json_str : str
A JSON string.
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.tojson : Used to save symbol into json string.
"""
if not isinstance(json_str, string_types):
raise TypeError('fname required to be string')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateFromJSON(c_str(json_str), ctypes.byref(handle)))
return Symbol(handle) | python | def load_json(json_str):
"""Loads symbol from json string.
Parameters
----------
json_str : str
A JSON string.
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.tojson : Used to save symbol into json string.
"""
if not isinstance(json_str, string_types):
raise TypeError('fname required to be string')
handle = SymbolHandle()
check_call(_LIB.MXSymbolCreateFromJSON(c_str(json_str), ctypes.byref(handle)))
return Symbol(handle) | [
"def",
"load_json",
"(",
"json_str",
")",
":",
"if",
"not",
"isinstance",
"(",
"json_str",
",",
"string_types",
")",
":",
"raise",
"TypeError",
"(",
"'fname required to be string'",
")",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolCreateFromJSON",
"(",
"c_str",
"(",
"json_str",
")",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"return",
"Symbol",
"(",
"handle",
")"
] | Loads symbol from json string.
Parameters
----------
json_str : str
A JSON string.
Returns
-------
sym : Symbol
The loaded symbol.
See Also
--------
Symbol.tojson : Used to save symbol into json string. | [
"Loads",
"symbol",
"from",
"json",
"string",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2718-L2739 |
23,657 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | maximum | def maximum(left, right):
"""Returns element-wise maximum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise maximum of the input symbols.
Examples
--------
>>> mx.sym.maximum(2, 3.5)
3.5
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.maximum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 4., 5., 4., 10.], dtype=float32)
>>> z = mx.sym.maximum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10., 4.], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Maximum(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._MaximumScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._MaximumScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return left if left > right else right
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | python | def maximum(left, right):
"""Returns element-wise maximum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise maximum of the input symbols.
Examples
--------
>>> mx.sym.maximum(2, 3.5)
3.5
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.maximum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 4., 5., 4., 10.], dtype=float32)
>>> z = mx.sym.maximum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10., 4.], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Maximum(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._MaximumScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._MaximumScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return left if left > right else right
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | [
"def",
"maximum",
"(",
"left",
",",
"right",
")",
":",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_Maximum",
"(",
"left",
",",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"_internal",
".",
"_MaximumScalar",
"(",
"left",
",",
"scalar",
"=",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_MaximumScalar",
"(",
"right",
",",
"scalar",
"=",
"left",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"left",
"if",
"left",
">",
"right",
"else",
"right",
"else",
":",
"raise",
"TypeError",
"(",
"'types (%s, %s) not supported'",
"%",
"(",
"str",
"(",
"type",
"(",
"left",
")",
")",
",",
"str",
"(",
"type",
"(",
"right",
")",
")",
")",
")"
] | Returns element-wise maximum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise maximum of the input symbols.
Examples
--------
>>> mx.sym.maximum(2, 3.5)
3.5
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.maximum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 4., 5., 4., 10.], dtype=float32)
>>> z = mx.sym.maximum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10., 4.], dtype=float32) | [
"Returns",
"element",
"-",
"wise",
"maximum",
"of",
"the",
"input",
"elements",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2831-L2870 |
23,658 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | minimum | def minimum(left, right):
"""Returns element-wise minimum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise minimum of the input symbols.
Examples
--------
>>> mx.sym.minimum(2, 3.5)
2
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.minimum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 3., 4., 2., 4.], dtype=float32)
>>> z = mx.sym.minimum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 3., 2.], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Minimum(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._MinimumScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._MinimumScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return left if left < right else right
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | python | def minimum(left, right):
"""Returns element-wise minimum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise minimum of the input symbols.
Examples
--------
>>> mx.sym.minimum(2, 3.5)
2
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.minimum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 3., 4., 2., 4.], dtype=float32)
>>> z = mx.sym.minimum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 3., 2.], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Minimum(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._MinimumScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._MinimumScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return left if left < right else right
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | [
"def",
"minimum",
"(",
"left",
",",
"right",
")",
":",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_Minimum",
"(",
"left",
",",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"_internal",
".",
"_MinimumScalar",
"(",
"left",
",",
"scalar",
"=",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_MinimumScalar",
"(",
"right",
",",
"scalar",
"=",
"left",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"left",
"if",
"left",
"<",
"right",
"else",
"right",
"else",
":",
"raise",
"TypeError",
"(",
"'types (%s, %s) not supported'",
"%",
"(",
"str",
"(",
"type",
"(",
"left",
")",
")",
",",
"str",
"(",
"type",
"(",
"right",
")",
")",
")",
")"
] | Returns element-wise minimum of the input elements.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First symbol to be compared.
right : Symbol or scalar
Second symbol to be compared.
Returns
-------
Symbol or scalar
The element-wise minimum of the input symbols.
Examples
--------
>>> mx.sym.minimum(2, 3.5)
2
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.minimum(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2,10]))[0].asnumpy()
array([ 3., 4., 2., 4.], dtype=float32)
>>> z = mx.sym.minimum(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 3., 2.], dtype=float32) | [
"Returns",
"element",
"-",
"wise",
"minimum",
"of",
"the",
"input",
"elements",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2875-L2914 |
23,659 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | hypot | def hypot(left, right):
"""Given the "legs" of a right triangle, returns its hypotenuse.
Equivalent to :math:`\\sqrt(left^2 + right^2)`, element-wise.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First leg of the triangle(s).
right : Symbol or scalar
Second leg of the triangle(s).
Returns
-------
Symbol or scalar
The hypotenuse of the triangle(s)
Examples
--------
>>> mx.sym.hypot(3, 4)
5.0
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.hypot(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2]))[0].asnumpy()
array([ 5., 6.40312433, 4.47213602], dtype=float32)
>>> z = mx.sym.hypot(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10.44030666, 4.47213602], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Hypot(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._HypotScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._HypotScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return _numpy.hypot(left, right)
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | python | def hypot(left, right):
"""Given the "legs" of a right triangle, returns its hypotenuse.
Equivalent to :math:`\\sqrt(left^2 + right^2)`, element-wise.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First leg of the triangle(s).
right : Symbol or scalar
Second leg of the triangle(s).
Returns
-------
Symbol or scalar
The hypotenuse of the triangle(s)
Examples
--------
>>> mx.sym.hypot(3, 4)
5.0
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.hypot(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2]))[0].asnumpy()
array([ 5., 6.40312433, 4.47213602], dtype=float32)
>>> z = mx.sym.hypot(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10.44030666, 4.47213602], dtype=float32)
"""
if isinstance(left, Symbol) and isinstance(right, Symbol):
return _internal._Hypot(left, right)
if isinstance(left, Symbol) and isinstance(right, Number):
return _internal._HypotScalar(left, scalar=right)
if isinstance(left, Number) and isinstance(right, Symbol):
return _internal._HypotScalar(right, scalar=left)
if isinstance(left, Number) and isinstance(right, Number):
return _numpy.hypot(left, right)
else:
raise TypeError('types (%s, %s) not supported' % (str(type(left)), str(type(right)))) | [
"def",
"hypot",
"(",
"left",
",",
"right",
")",
":",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_Hypot",
"(",
"left",
",",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Symbol",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"_internal",
".",
"_HypotScalar",
"(",
"left",
",",
"scalar",
"=",
"right",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Symbol",
")",
":",
"return",
"_internal",
".",
"_HypotScalar",
"(",
"right",
",",
"scalar",
"=",
"left",
")",
"if",
"isinstance",
"(",
"left",
",",
"Number",
")",
"and",
"isinstance",
"(",
"right",
",",
"Number",
")",
":",
"return",
"_numpy",
".",
"hypot",
"(",
"left",
",",
"right",
")",
"else",
":",
"raise",
"TypeError",
"(",
"'types (%s, %s) not supported'",
"%",
"(",
"str",
"(",
"type",
"(",
"left",
")",
")",
",",
"str",
"(",
"type",
"(",
"right",
")",
")",
")",
")"
] | Given the "legs" of a right triangle, returns its hypotenuse.
Equivalent to :math:`\\sqrt(left^2 + right^2)`, element-wise.
Both inputs can be Symbol or scalar number. Broadcasting is not supported.
Parameters
---------
left : Symbol or scalar
First leg of the triangle(s).
right : Symbol or scalar
Second leg of the triangle(s).
Returns
-------
Symbol or scalar
The hypotenuse of the triangle(s)
Examples
--------
>>> mx.sym.hypot(3, 4)
5.0
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.hypot(x, 4)
>>> z.eval(x=mx.nd.array([3,5,2]))[0].asnumpy()
array([ 5., 6.40312433, 4.47213602], dtype=float32)
>>> z = mx.sym.hypot(x, y)
>>> z.eval(x=mx.nd.array([3,4]), y=mx.nd.array([10,2]))[0].asnumpy()
array([ 10.44030666, 4.47213602], dtype=float32) | [
"Given",
"the",
"legs",
"of",
"a",
"right",
"triangle",
"returns",
"its",
"hypotenuse",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2919-L2959 |
23,660 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | eye | def eye(N, M=0, k=0, dtype=None, **kwargs):
"""Returns a new symbol of 2-D shpae, filled with ones on the diagonal and zeros elsewhere.
Parameters
----------
N: int
Number of rows in the output.
M: int, optional
Number of columns in the output. If 0, defaults to N.
k: int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal,
and a negative value to a lower diagonal.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol.
"""
if dtype is None:
dtype = _numpy.float32
return _internal._eye(N, M, k, dtype=dtype, **kwargs) | python | def eye(N, M=0, k=0, dtype=None, **kwargs):
"""Returns a new symbol of 2-D shpae, filled with ones on the diagonal and zeros elsewhere.
Parameters
----------
N: int
Number of rows in the output.
M: int, optional
Number of columns in the output. If 0, defaults to N.
k: int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal,
and a negative value to a lower diagonal.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol.
"""
if dtype is None:
dtype = _numpy.float32
return _internal._eye(N, M, k, dtype=dtype, **kwargs) | [
"def",
"eye",
"(",
"N",
",",
"M",
"=",
"0",
",",
"k",
"=",
"0",
",",
"dtype",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"dtype",
"is",
"None",
":",
"dtype",
"=",
"_numpy",
".",
"float32",
"return",
"_internal",
".",
"_eye",
"(",
"N",
",",
"M",
",",
"k",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")"
] | Returns a new symbol of 2-D shpae, filled with ones on the diagonal and zeros elsewhere.
Parameters
----------
N: int
Number of rows in the output.
M: int, optional
Number of columns in the output. If 0, defaults to N.
k: int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal,
and a negative value to a lower diagonal.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol. | [
"Returns",
"a",
"new",
"symbol",
"of",
"2",
"-",
"D",
"shpae",
"filled",
"with",
"ones",
"on",
"the",
"diagonal",
"and",
"zeros",
"elsewhere",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2962-L2985 |
23,661 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | zeros | def zeros(shape, dtype=None, **kwargs):
"""Returns a new symbol of given shape and type, filled with zeros.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol.
"""
if dtype is None:
dtype = _numpy.float32
return _internal._zeros(shape=shape, dtype=dtype, **kwargs) | python | def zeros(shape, dtype=None, **kwargs):
"""Returns a new symbol of given shape and type, filled with zeros.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol.
"""
if dtype is None:
dtype = _numpy.float32
return _internal._zeros(shape=shape, dtype=dtype, **kwargs) | [
"def",
"zeros",
"(",
"shape",
",",
"dtype",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"dtype",
"is",
"None",
":",
"dtype",
"=",
"_numpy",
".",
"float32",
"return",
"_internal",
".",
"_zeros",
"(",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")"
] | Returns a new symbol of given shape and type, filled with zeros.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol. | [
"Returns",
"a",
"new",
"symbol",
"of",
"given",
"shape",
"and",
"type",
"filled",
"with",
"zeros",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2987-L3004 |
23,662 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | ones | def ones(shape, dtype=None, **kwargs):
"""Returns a new symbol of given shape and type, filled with ones.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol
"""
if dtype is None:
dtype = _numpy.float32
return _internal._ones(shape=shape, dtype=dtype, **kwargs) | python | def ones(shape, dtype=None, **kwargs):
"""Returns a new symbol of given shape and type, filled with ones.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol
"""
if dtype is None:
dtype = _numpy.float32
return _internal._ones(shape=shape, dtype=dtype, **kwargs) | [
"def",
"ones",
"(",
"shape",
",",
"dtype",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"dtype",
"is",
"None",
":",
"dtype",
"=",
"_numpy",
".",
"float32",
"return",
"_internal",
".",
"_ones",
"(",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")"
] | Returns a new symbol of given shape and type, filled with ones.
Parameters
----------
shape : int or sequence of ints
Shape of the new array.
dtype : str or numpy.dtype, optional
The value type of the inner value, default to ``np.float32``.
Returns
-------
out : Symbol
The created Symbol | [
"Returns",
"a",
"new",
"symbol",
"of",
"given",
"shape",
"and",
"type",
"filled",
"with",
"ones",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L3007-L3024 |
23,663 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.name | def name(self):
"""Gets name string from the symbol, this function only works for non-grouped symbol.
Returns
-------
value : str
The name of this symbol, returns ``None`` for grouped symbol.
"""
ret = ctypes.c_char_p()
success = ctypes.c_int()
check_call(_LIB.MXSymbolGetName(
self.handle, ctypes.byref(ret), ctypes.byref(success)))
if success.value != 0:
return py_str(ret.value)
else:
return None | python | def name(self):
"""Gets name string from the symbol, this function only works for non-grouped symbol.
Returns
-------
value : str
The name of this symbol, returns ``None`` for grouped symbol.
"""
ret = ctypes.c_char_p()
success = ctypes.c_int()
check_call(_LIB.MXSymbolGetName(
self.handle, ctypes.byref(ret), ctypes.byref(success)))
if success.value != 0:
return py_str(ret.value)
else:
return None | [
"def",
"name",
"(",
"self",
")",
":",
"ret",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"success",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolGetName",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"ret",
")",
",",
"ctypes",
".",
"byref",
"(",
"success",
")",
")",
")",
"if",
"success",
".",
"value",
"!=",
"0",
":",
"return",
"py_str",
"(",
"ret",
".",
"value",
")",
"else",
":",
"return",
"None"
] | Gets name string from the symbol, this function only works for non-grouped symbol.
Returns
-------
value : str
The name of this symbol, returns ``None`` for grouped symbol. | [
"Gets",
"name",
"string",
"from",
"the",
"symbol",
"this",
"function",
"only",
"works",
"for",
"non",
"-",
"grouped",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L534-L549 |
23,664 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.attr | def attr(self, key):
"""Returns the attribute string for corresponding input key from the symbol.
This function only works for non-grouped symbols.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.attr('mood')
'angry'
Parameters
----------
key : str
The key corresponding to the desired attribute.
Returns
-------
value : str
The desired attribute value, returns ``None`` if the attribute does not exist.
"""
ret = ctypes.c_char_p()
success = ctypes.c_int()
check_call(_LIB.MXSymbolGetAttr(
self.handle, c_str(key), ctypes.byref(ret), ctypes.byref(success)))
if success.value != 0:
return py_str(ret.value)
else:
return None | python | def attr(self, key):
"""Returns the attribute string for corresponding input key from the symbol.
This function only works for non-grouped symbols.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.attr('mood')
'angry'
Parameters
----------
key : str
The key corresponding to the desired attribute.
Returns
-------
value : str
The desired attribute value, returns ``None`` if the attribute does not exist.
"""
ret = ctypes.c_char_p()
success = ctypes.c_int()
check_call(_LIB.MXSymbolGetAttr(
self.handle, c_str(key), ctypes.byref(ret), ctypes.byref(success)))
if success.value != 0:
return py_str(ret.value)
else:
return None | [
"def",
"attr",
"(",
"self",
",",
"key",
")",
":",
"ret",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"success",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolGetAttr",
"(",
"self",
".",
"handle",
",",
"c_str",
"(",
"key",
")",
",",
"ctypes",
".",
"byref",
"(",
"ret",
")",
",",
"ctypes",
".",
"byref",
"(",
"success",
")",
")",
")",
"if",
"success",
".",
"value",
"!=",
"0",
":",
"return",
"py_str",
"(",
"ret",
".",
"value",
")",
"else",
":",
"return",
"None"
] | Returns the attribute string for corresponding input key from the symbol.
This function only works for non-grouped symbols.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.attr('mood')
'angry'
Parameters
----------
key : str
The key corresponding to the desired attribute.
Returns
-------
value : str
The desired attribute value, returns ``None`` if the attribute does not exist. | [
"Returns",
"the",
"attribute",
"string",
"for",
"corresponding",
"input",
"key",
"from",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L551-L579 |
23,665 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.list_attr | def list_attr(self, recursive=False):
"""Gets all attributes from the symbol.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.list_attr()
{'mood': 'angry'}
Returns
-------
ret : Dict of str to str
A dictionary mapping attribute keys to values.
"""
if recursive:
raise DeprecationWarning("Symbol.list_attr with recursive=True has been deprecated. "
"Please use attr_dict instead.")
size = mx_uint()
pairs = ctypes.POINTER(ctypes.c_char_p)()
f_handle = _LIB.MXSymbolListAttrShallow
check_call(f_handle(self.handle, ctypes.byref(size), ctypes.byref(pairs)))
return {py_str(pairs[i * 2]): py_str(pairs[i * 2 + 1]) for i in range(size.value)} | python | def list_attr(self, recursive=False):
"""Gets all attributes from the symbol.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.list_attr()
{'mood': 'angry'}
Returns
-------
ret : Dict of str to str
A dictionary mapping attribute keys to values.
"""
if recursive:
raise DeprecationWarning("Symbol.list_attr with recursive=True has been deprecated. "
"Please use attr_dict instead.")
size = mx_uint()
pairs = ctypes.POINTER(ctypes.c_char_p)()
f_handle = _LIB.MXSymbolListAttrShallow
check_call(f_handle(self.handle, ctypes.byref(size), ctypes.byref(pairs)))
return {py_str(pairs[i * 2]): py_str(pairs[i * 2 + 1]) for i in range(size.value)} | [
"def",
"list_attr",
"(",
"self",
",",
"recursive",
"=",
"False",
")",
":",
"if",
"recursive",
":",
"raise",
"DeprecationWarning",
"(",
"\"Symbol.list_attr with recursive=True has been deprecated. \"",
"\"Please use attr_dict instead.\"",
")",
"size",
"=",
"mx_uint",
"(",
")",
"pairs",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"f_handle",
"=",
"_LIB",
".",
"MXSymbolListAttrShallow",
"check_call",
"(",
"f_handle",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"pairs",
")",
")",
")",
"return",
"{",
"py_str",
"(",
"pairs",
"[",
"i",
"*",
"2",
"]",
")",
":",
"py_str",
"(",
"pairs",
"[",
"i",
"*",
"2",
"+",
"1",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
"}"
] | Gets all attributes from the symbol.
Example
-------
>>> data = mx.sym.Variable('data', attr={'mood': 'angry'})
>>> data.list_attr()
{'mood': 'angry'}
Returns
-------
ret : Dict of str to str
A dictionary mapping attribute keys to values. | [
"Gets",
"all",
"attributes",
"from",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L581-L602 |
23,666 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.attr_dict | def attr_dict(self):
"""Recursively gets all attributes from the symbol and its children.
Example
-------
>>> a = mx.sym.Variable('a', attr={'a1':'a2'})
>>> b = mx.sym.Variable('b', attr={'b1':'b2'})
>>> c = a+b
>>> c.attr_dict()
{'a': {'a1': 'a2'}, 'b': {'b1': 'b2'}}
Returns
-------
ret : Dict of str to dict
There is a key in the returned dict for every child with non-empty attribute set.
For each symbol, the name of the symbol is its key in the dict
and the correspond value is that symbol's attribute list (itself a dictionary).
"""
size = mx_uint()
pairs = ctypes.POINTER(ctypes.c_char_p)()
f_handle = _LIB.MXSymbolListAttr
check_call(f_handle(self.handle, ctypes.byref(size), ctypes.byref(pairs)))
ret = {}
for i in range(size.value):
name, key = py_str(pairs[i * 2]).split('$')
val = py_str(pairs[i * 2 + 1])
if name not in ret:
ret[name] = {}
ret[name][key] = val
return ret | python | def attr_dict(self):
"""Recursively gets all attributes from the symbol and its children.
Example
-------
>>> a = mx.sym.Variable('a', attr={'a1':'a2'})
>>> b = mx.sym.Variable('b', attr={'b1':'b2'})
>>> c = a+b
>>> c.attr_dict()
{'a': {'a1': 'a2'}, 'b': {'b1': 'b2'}}
Returns
-------
ret : Dict of str to dict
There is a key in the returned dict for every child with non-empty attribute set.
For each symbol, the name of the symbol is its key in the dict
and the correspond value is that symbol's attribute list (itself a dictionary).
"""
size = mx_uint()
pairs = ctypes.POINTER(ctypes.c_char_p)()
f_handle = _LIB.MXSymbolListAttr
check_call(f_handle(self.handle, ctypes.byref(size), ctypes.byref(pairs)))
ret = {}
for i in range(size.value):
name, key = py_str(pairs[i * 2]).split('$')
val = py_str(pairs[i * 2 + 1])
if name not in ret:
ret[name] = {}
ret[name][key] = val
return ret | [
"def",
"attr_dict",
"(",
"self",
")",
":",
"size",
"=",
"mx_uint",
"(",
")",
"pairs",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"f_handle",
"=",
"_LIB",
".",
"MXSymbolListAttr",
"check_call",
"(",
"f_handle",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"pairs",
")",
")",
")",
"ret",
"=",
"{",
"}",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
":",
"name",
",",
"key",
"=",
"py_str",
"(",
"pairs",
"[",
"i",
"*",
"2",
"]",
")",
".",
"split",
"(",
"'$'",
")",
"val",
"=",
"py_str",
"(",
"pairs",
"[",
"i",
"*",
"2",
"+",
"1",
"]",
")",
"if",
"name",
"not",
"in",
"ret",
":",
"ret",
"[",
"name",
"]",
"=",
"{",
"}",
"ret",
"[",
"name",
"]",
"[",
"key",
"]",
"=",
"val",
"return",
"ret"
] | Recursively gets all attributes from the symbol and its children.
Example
-------
>>> a = mx.sym.Variable('a', attr={'a1':'a2'})
>>> b = mx.sym.Variable('b', attr={'b1':'b2'})
>>> c = a+b
>>> c.attr_dict()
{'a': {'a1': 'a2'}, 'b': {'b1': 'b2'}}
Returns
-------
ret : Dict of str to dict
There is a key in the returned dict for every child with non-empty attribute set.
For each symbol, the name of the symbol is its key in the dict
and the correspond value is that symbol's attribute list (itself a dictionary). | [
"Recursively",
"gets",
"all",
"attributes",
"from",
"the",
"symbol",
"and",
"its",
"children",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L604-L633 |
23,667 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol._set_attr | def _set_attr(self, **kwargs):
"""Sets an attribute of the symbol.
For example. A._set_attr(foo="bar") adds the mapping ``"{foo: bar}"``
to the symbol's attribute dictionary.
Parameters
----------
**kwargs
The attributes to set
"""
for key, value in kwargs.items():
if not isinstance(value, string_types):
raise ValueError("Set Attr only accepts string values")
check_call(_LIB.MXSymbolSetAttr(
self.handle, c_str(key), c_str(str(value)))) | python | def _set_attr(self, **kwargs):
"""Sets an attribute of the symbol.
For example. A._set_attr(foo="bar") adds the mapping ``"{foo: bar}"``
to the symbol's attribute dictionary.
Parameters
----------
**kwargs
The attributes to set
"""
for key, value in kwargs.items():
if not isinstance(value, string_types):
raise ValueError("Set Attr only accepts string values")
check_call(_LIB.MXSymbolSetAttr(
self.handle, c_str(key), c_str(str(value)))) | [
"def",
"_set_attr",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"key",
",",
"value",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"not",
"isinstance",
"(",
"value",
",",
"string_types",
")",
":",
"raise",
"ValueError",
"(",
"\"Set Attr only accepts string values\"",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolSetAttr",
"(",
"self",
".",
"handle",
",",
"c_str",
"(",
"key",
")",
",",
"c_str",
"(",
"str",
"(",
"value",
")",
")",
")",
")"
] | Sets an attribute of the symbol.
For example. A._set_attr(foo="bar") adds the mapping ``"{foo: bar}"``
to the symbol's attribute dictionary.
Parameters
----------
**kwargs
The attributes to set | [
"Sets",
"an",
"attribute",
"of",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L635-L650 |
23,668 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.get_internals | def get_internals(self):
"""Gets a new grouped symbol `sgroup`. The output of `sgroup` is a list of
outputs of all of the internal nodes.
Consider the following code:
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> d = c.get_internals()
>>> d
<Symbol Grouped>
>>> d.list_outputs()
['a', 'b', '_plus4_output']
Returns
-------
sgroup : Symbol
A symbol group containing all internal and leaf nodes of the computation graph
used to compute the symbol.
"""
handle = SymbolHandle()
check_call(_LIB.MXSymbolGetInternals(
self.handle, ctypes.byref(handle)))
return Symbol(handle=handle) | python | def get_internals(self):
"""Gets a new grouped symbol `sgroup`. The output of `sgroup` is a list of
outputs of all of the internal nodes.
Consider the following code:
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> d = c.get_internals()
>>> d
<Symbol Grouped>
>>> d.list_outputs()
['a', 'b', '_plus4_output']
Returns
-------
sgroup : Symbol
A symbol group containing all internal and leaf nodes of the computation graph
used to compute the symbol.
"""
handle = SymbolHandle()
check_call(_LIB.MXSymbolGetInternals(
self.handle, ctypes.byref(handle)))
return Symbol(handle=handle) | [
"def",
"get_internals",
"(",
"self",
")",
":",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolGetInternals",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"return",
"Symbol",
"(",
"handle",
"=",
"handle",
")"
] | Gets a new grouped symbol `sgroup`. The output of `sgroup` is a list of
outputs of all of the internal nodes.
Consider the following code:
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> d = c.get_internals()
>>> d
<Symbol Grouped>
>>> d.list_outputs()
['a', 'b', '_plus4_output']
Returns
-------
sgroup : Symbol
A symbol group containing all internal and leaf nodes of the computation graph
used to compute the symbol. | [
"Gets",
"a",
"new",
"grouped",
"symbol",
"sgroup",
".",
"The",
"output",
"of",
"sgroup",
"is",
"a",
"list",
"of",
"outputs",
"of",
"all",
"of",
"the",
"internal",
"nodes",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L652-L678 |
23,669 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.get_children | def get_children(self):
"""Gets a new grouped symbol whose output contains
inputs to output nodes of the original symbol.
Example
-------
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.Variable('z')
>>> a = y+z
>>> b = x+a
>>> b.get_children()
<Symbol Grouped>
>>> b.get_children().list_outputs()
['x', '_plus10_output']
>>> b.get_children().get_children().list_outputs()
['y', 'z']
Returns
-------
sgroup : Symbol or None
The children of the head node. If the symbol has no
inputs then ``None`` will be returned.
"""
handle = SymbolHandle()
check_call(_LIB.MXSymbolGetChildren(
self.handle, ctypes.byref(handle)))
ret = Symbol(handle=handle)
if len(ret.list_outputs()) == 0:
return None
return ret | python | def get_children(self):
"""Gets a new grouped symbol whose output contains
inputs to output nodes of the original symbol.
Example
-------
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.Variable('z')
>>> a = y+z
>>> b = x+a
>>> b.get_children()
<Symbol Grouped>
>>> b.get_children().list_outputs()
['x', '_plus10_output']
>>> b.get_children().get_children().list_outputs()
['y', 'z']
Returns
-------
sgroup : Symbol or None
The children of the head node. If the symbol has no
inputs then ``None`` will be returned.
"""
handle = SymbolHandle()
check_call(_LIB.MXSymbolGetChildren(
self.handle, ctypes.byref(handle)))
ret = Symbol(handle=handle)
if len(ret.list_outputs()) == 0:
return None
return ret | [
"def",
"get_children",
"(",
"self",
")",
":",
"handle",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolGetChildren",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"ret",
"=",
"Symbol",
"(",
"handle",
"=",
"handle",
")",
"if",
"len",
"(",
"ret",
".",
"list_outputs",
"(",
")",
")",
"==",
"0",
":",
"return",
"None",
"return",
"ret"
] | Gets a new grouped symbol whose output contains
inputs to output nodes of the original symbol.
Example
-------
>>> x = mx.sym.Variable('x')
>>> y = mx.sym.Variable('y')
>>> z = mx.sym.Variable('z')
>>> a = y+z
>>> b = x+a
>>> b.get_children()
<Symbol Grouped>
>>> b.get_children().list_outputs()
['x', '_plus10_output']
>>> b.get_children().get_children().list_outputs()
['y', 'z']
Returns
-------
sgroup : Symbol or None
The children of the head node. If the symbol has no
inputs then ``None`` will be returned. | [
"Gets",
"a",
"new",
"grouped",
"symbol",
"whose",
"output",
"contains",
"inputs",
"to",
"output",
"nodes",
"of",
"the",
"original",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L680-L710 |
23,670 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.list_arguments | def list_arguments(self):
"""Lists all the arguments in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_arguments
['a', 'b']
Returns
-------
args : list of string
List containing the names of all the arguments required to compute the symbol.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListArguments(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | python | def list_arguments(self):
"""Lists all the arguments in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_arguments
['a', 'b']
Returns
-------
args : list of string
List containing the names of all the arguments required to compute the symbol.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListArguments(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | [
"def",
"list_arguments",
"(",
"self",
")",
":",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"sarr",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolListArguments",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"sarr",
")",
")",
")",
"return",
"[",
"py_str",
"(",
"sarr",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
"]"
] | Lists all the arguments in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_arguments
['a', 'b']
Returns
-------
args : list of string
List containing the names of all the arguments required to compute the symbol. | [
"Lists",
"all",
"the",
"arguments",
"in",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L712-L732 |
23,671 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.list_outputs | def list_outputs(self):
"""Lists all the outputs in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_outputs()
['_plus12_output']
Returns
-------
list of str
List of all the outputs.
For most symbols, this list contains only the name of this symbol.
For symbol groups, this is a list with the names of all symbols
in the group.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListOutputs(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | python | def list_outputs(self):
"""Lists all the outputs in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_outputs()
['_plus12_output']
Returns
-------
list of str
List of all the outputs.
For most symbols, this list contains only the name of this symbol.
For symbol groups, this is a list with the names of all symbols
in the group.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListOutputs(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | [
"def",
"list_outputs",
"(",
"self",
")",
":",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"sarr",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolListOutputs",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"sarr",
")",
")",
")",
"return",
"[",
"py_str",
"(",
"sarr",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
"]"
] | Lists all the outputs in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_outputs()
['_plus12_output']
Returns
-------
list of str
List of all the outputs.
For most symbols, this list contains only the name of this symbol.
For symbol groups, this is a list with the names of all symbols
in the group. | [
"Lists",
"all",
"the",
"outputs",
"in",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L734-L757 |
23,672 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.list_auxiliary_states | def list_auxiliary_states(self):
"""Lists all the auxiliary states in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_auxiliary_states()
[]
Example of auxiliary states in `BatchNorm`.
>>> data = mx.symbol.Variable('data')
>>> weight = mx.sym.Variable(name='fc1_weight')
>>> fc1 = mx.symbol.FullyConnected(data = data, weight=weight, name='fc1', num_hidden=128)
>>> fc2 = mx.symbol.BatchNorm(fc1, name='batchnorm0')
>>> fc2.list_auxiliary_states()
['batchnorm0_moving_mean', 'batchnorm0_moving_var']
Returns
-------
aux_states : list of str
List of the auxiliary states in input symbol.
Notes
-----
Auxiliary states are special states of symbols that do not correspond to an argument,
and are not updated by gradient descent. Common examples of auxiliary states
include the `moving_mean` and `moving_variance` in `BatchNorm`.
Most operators do not have auxiliary states.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListAuxiliaryStates(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | python | def list_auxiliary_states(self):
"""Lists all the auxiliary states in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_auxiliary_states()
[]
Example of auxiliary states in `BatchNorm`.
>>> data = mx.symbol.Variable('data')
>>> weight = mx.sym.Variable(name='fc1_weight')
>>> fc1 = mx.symbol.FullyConnected(data = data, weight=weight, name='fc1', num_hidden=128)
>>> fc2 = mx.symbol.BatchNorm(fc1, name='batchnorm0')
>>> fc2.list_auxiliary_states()
['batchnorm0_moving_mean', 'batchnorm0_moving_var']
Returns
-------
aux_states : list of str
List of the auxiliary states in input symbol.
Notes
-----
Auxiliary states are special states of symbols that do not correspond to an argument,
and are not updated by gradient descent. Common examples of auxiliary states
include the `moving_mean` and `moving_variance` in `BatchNorm`.
Most operators do not have auxiliary states.
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXSymbolListAuxiliaryStates(
self.handle, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | [
"def",
"list_auxiliary_states",
"(",
"self",
")",
":",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"sarr",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolListAuxiliaryStates",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"sarr",
")",
")",
")",
"return",
"[",
"py_str",
"(",
"sarr",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
"]"
] | Lists all the auxiliary states in the symbol.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> c.list_auxiliary_states()
[]
Example of auxiliary states in `BatchNorm`.
>>> data = mx.symbol.Variable('data')
>>> weight = mx.sym.Variable(name='fc1_weight')
>>> fc1 = mx.symbol.FullyConnected(data = data, weight=weight, name='fc1', num_hidden=128)
>>> fc2 = mx.symbol.BatchNorm(fc1, name='batchnorm0')
>>> fc2.list_auxiliary_states()
['batchnorm0_moving_mean', 'batchnorm0_moving_var']
Returns
-------
aux_states : list of str
List of the auxiliary states in input symbol.
Notes
-----
Auxiliary states are special states of symbols that do not correspond to an argument,
and are not updated by gradient descent. Common examples of auxiliary states
include the `moving_mean` and `moving_variance` in `BatchNorm`.
Most operators do not have auxiliary states. | [
"Lists",
"all",
"the",
"auxiliary",
"states",
"in",
"the",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L779-L815 |
23,673 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.list_inputs | def list_inputs(self):
"""Lists all arguments and auxiliary states of this Symbol.
Returns
-------
inputs : list of str
List of all inputs.
Examples
--------
>>> bn = mx.sym.BatchNorm(name='bn')
>>> bn.list_arguments()
['bn_data', 'bn_gamma', 'bn_beta']
>>> bn.list_auxiliary_states()
['bn_moving_mean', 'bn_moving_var']
>>> bn.list_inputs()
['bn_data', 'bn_gamma', 'bn_beta', 'bn_moving_mean', 'bn_moving_var']
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.NNSymbolListInputNames(
self.handle, 0, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | python | def list_inputs(self):
"""Lists all arguments and auxiliary states of this Symbol.
Returns
-------
inputs : list of str
List of all inputs.
Examples
--------
>>> bn = mx.sym.BatchNorm(name='bn')
>>> bn.list_arguments()
['bn_data', 'bn_gamma', 'bn_beta']
>>> bn.list_auxiliary_states()
['bn_moving_mean', 'bn_moving_var']
>>> bn.list_inputs()
['bn_data', 'bn_gamma', 'bn_beta', 'bn_moving_mean', 'bn_moving_var']
"""
size = ctypes.c_uint()
sarr = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.NNSymbolListInputNames(
self.handle, 0, ctypes.byref(size), ctypes.byref(sarr)))
return [py_str(sarr[i]) for i in range(size.value)] | [
"def",
"list_inputs",
"(",
"self",
")",
":",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"sarr",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"NNSymbolListInputNames",
"(",
"self",
".",
"handle",
",",
"0",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"sarr",
")",
")",
")",
"return",
"[",
"py_str",
"(",
"sarr",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
"]"
] | Lists all arguments and auxiliary states of this Symbol.
Returns
-------
inputs : list of str
List of all inputs.
Examples
--------
>>> bn = mx.sym.BatchNorm(name='bn')
>>> bn.list_arguments()
['bn_data', 'bn_gamma', 'bn_beta']
>>> bn.list_auxiliary_states()
['bn_moving_mean', 'bn_moving_var']
>>> bn.list_inputs()
['bn_data', 'bn_gamma', 'bn_beta', 'bn_moving_mean', 'bn_moving_var'] | [
"Lists",
"all",
"arguments",
"and",
"auxiliary",
"states",
"of",
"this",
"Symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L817-L839 |
23,674 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.infer_type | def infer_type(self, *args, **kwargs):
"""Infers the type of all arguments and all outputs, given the known types
for some arguments.
This function takes the known types of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing types.
Inconsistencies in the known types will cause an error to be raised.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_types, out_types, aux_types = c.infer_type(a='float32')
>>> arg_types
[<type 'numpy.float32'>, <type 'numpy.float32'>]
>>> out_types
[<type 'numpy.float32'>]
>>> aux_types
[]
Parameters
----------
*args :
Type of known arguments in a positional way.
Unknown type can be marked as None.
**kwargs :
Keyword arguments of known types.
Returns
-------
arg_types : list of numpy.dtype or None
List of argument types.
The order is same as the order of list_arguments().
out_types : list of numpy.dtype or None
List of output types.
The order is same as the order of list_outputs().
aux_types : list of numpy.dtype or None
List of auxiliary state types.
The order is same as the order of list_auxiliary_states().
"""
try:
res = self._infer_type_impl(False, *args, **kwargs)
if res[1] is None:
arg_shapes, _, _ = self._infer_type_impl(True, *args, **kwargs)
arg_names = self.list_arguments()
unknowns = []
for name, dtype in zip(arg_names, arg_shapes):
if not dtype:
if len(unknowns) >= 10:
unknowns.append('...')
break
unknowns.append('%s: %s' % (name, str(dtype)))
warnings.warn(
"Cannot decide type for the following arguments. " +
"Consider providing them as input:\n\t" +
"\n\t".join(unknowns), stacklevel=2)
return res
except MXNetError:
print("infer_type error. Arguments:")
for i, arg in enumerate(args):
print(" #%d: %s" % (i, arg))
for k, v in kwargs.items():
print(" %s: %s" % (k, v))
raise | python | def infer_type(self, *args, **kwargs):
"""Infers the type of all arguments and all outputs, given the known types
for some arguments.
This function takes the known types of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing types.
Inconsistencies in the known types will cause an error to be raised.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_types, out_types, aux_types = c.infer_type(a='float32')
>>> arg_types
[<type 'numpy.float32'>, <type 'numpy.float32'>]
>>> out_types
[<type 'numpy.float32'>]
>>> aux_types
[]
Parameters
----------
*args :
Type of known arguments in a positional way.
Unknown type can be marked as None.
**kwargs :
Keyword arguments of known types.
Returns
-------
arg_types : list of numpy.dtype or None
List of argument types.
The order is same as the order of list_arguments().
out_types : list of numpy.dtype or None
List of output types.
The order is same as the order of list_outputs().
aux_types : list of numpy.dtype or None
List of auxiliary state types.
The order is same as the order of list_auxiliary_states().
"""
try:
res = self._infer_type_impl(False, *args, **kwargs)
if res[1] is None:
arg_shapes, _, _ = self._infer_type_impl(True, *args, **kwargs)
arg_names = self.list_arguments()
unknowns = []
for name, dtype in zip(arg_names, arg_shapes):
if not dtype:
if len(unknowns) >= 10:
unknowns.append('...')
break
unknowns.append('%s: %s' % (name, str(dtype)))
warnings.warn(
"Cannot decide type for the following arguments. " +
"Consider providing them as input:\n\t" +
"\n\t".join(unknowns), stacklevel=2)
return res
except MXNetError:
print("infer_type error. Arguments:")
for i, arg in enumerate(args):
print(" #%d: %s" % (i, arg))
for k, v in kwargs.items():
print(" %s: %s" % (k, v))
raise | [
"def",
"infer_type",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"res",
"=",
"self",
".",
"_infer_type_impl",
"(",
"False",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"res",
"[",
"1",
"]",
"is",
"None",
":",
"arg_shapes",
",",
"_",
",",
"_",
"=",
"self",
".",
"_infer_type_impl",
"(",
"True",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"arg_names",
"=",
"self",
".",
"list_arguments",
"(",
")",
"unknowns",
"=",
"[",
"]",
"for",
"name",
",",
"dtype",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
":",
"if",
"not",
"dtype",
":",
"if",
"len",
"(",
"unknowns",
")",
">=",
"10",
":",
"unknowns",
".",
"append",
"(",
"'...'",
")",
"break",
"unknowns",
".",
"append",
"(",
"'%s: %s'",
"%",
"(",
"name",
",",
"str",
"(",
"dtype",
")",
")",
")",
"warnings",
".",
"warn",
"(",
"\"Cannot decide type for the following arguments. \"",
"+",
"\"Consider providing them as input:\\n\\t\"",
"+",
"\"\\n\\t\"",
".",
"join",
"(",
"unknowns",
")",
",",
"stacklevel",
"=",
"2",
")",
"return",
"res",
"except",
"MXNetError",
":",
"print",
"(",
"\"infer_type error. Arguments:\"",
")",
"for",
"i",
",",
"arg",
"in",
"enumerate",
"(",
"args",
")",
":",
"print",
"(",
"\" #%d: %s\"",
"%",
"(",
"i",
",",
"arg",
")",
")",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"print",
"(",
"\" %s: %s\"",
"%",
"(",
"k",
",",
"v",
")",
")",
"raise"
] | Infers the type of all arguments and all outputs, given the known types
for some arguments.
This function takes the known types of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing types.
Inconsistencies in the known types will cause an error to be raised.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_types, out_types, aux_types = c.infer_type(a='float32')
>>> arg_types
[<type 'numpy.float32'>, <type 'numpy.float32'>]
>>> out_types
[<type 'numpy.float32'>]
>>> aux_types
[]
Parameters
----------
*args :
Type of known arguments in a positional way.
Unknown type can be marked as None.
**kwargs :
Keyword arguments of known types.
Returns
-------
arg_types : list of numpy.dtype or None
List of argument types.
The order is same as the order of list_arguments().
out_types : list of numpy.dtype or None
List of output types.
The order is same as the order of list_outputs().
aux_types : list of numpy.dtype or None
List of auxiliary state types.
The order is same as the order of list_auxiliary_states(). | [
"Infers",
"the",
"type",
"of",
"all",
"arguments",
"and",
"all",
"outputs",
"given",
"the",
"known",
"types",
"for",
"some",
"arguments",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L841-L908 |
23,675 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol._infer_type_impl | def _infer_type_impl(self, partial, *args, **kwargs):
"""The actual implementation for calling type inference API."""
# pylint: disable=too-many-locals
if len(args) != 0 and len(kwargs) != 0:
raise ValueError('Can only specify known argument \
types either by positional or kwargs way.')
sdata = []
if len(args) != 0:
keys = c_array(ctypes.c_char_p, [])
for s in args:
if s is not None:
s = _numpy.dtype(s).type
if s not in _DTYPE_NP_TO_MX:
raise TypeError('Argument need to be one of ' + str(_DTYPE_NP_TO_MX))
sdata.append(_DTYPE_NP_TO_MX[s])
else:
sdata.append(-1)
else:
str_keys = []
for k, v in kwargs.items():
v = _numpy.dtype(v).type
if v in _DTYPE_NP_TO_MX:
str_keys.append(k)
sdata.append(_DTYPE_NP_TO_MX[v])
keys = c_str_array(str_keys)
arg_type_size = mx_uint()
arg_type_data = ctypes.POINTER(ctypes.c_int)()
out_type_size = mx_uint()
out_type_data = ctypes.POINTER(ctypes.c_int)()
aux_type_size = mx_uint()
aux_type_data = ctypes.POINTER(ctypes.c_int)()
complete = ctypes.c_int()
if partial:
infer_func = _LIB.MXSymbolInferTypePartial
else:
infer_func = _LIB.MXSymbolInferType
check_call(infer_func(
self.handle,
mx_uint(len(sdata)),
keys,
c_array_buf(ctypes.c_int, array('i', sdata)),
ctypes.byref(arg_type_size),
ctypes.byref(arg_type_data),
ctypes.byref(out_type_size),
ctypes.byref(out_type_data),
ctypes.byref(aux_type_size),
ctypes.byref(aux_type_data),
ctypes.byref(complete)))
if complete.value != 0:
arg_types = [
_DTYPE_MX_TO_NP[arg_type_data[i]] for i in range(arg_type_size.value)]
out_types = [
_DTYPE_MX_TO_NP[out_type_data[i]] for i in range(out_type_size.value)]
aux_types = [
_DTYPE_MX_TO_NP[aux_type_data[i]] for i in range(aux_type_size.value)]
return (arg_types, out_types, aux_types)
else:
return (None, None, None) | python | def _infer_type_impl(self, partial, *args, **kwargs):
"""The actual implementation for calling type inference API."""
# pylint: disable=too-many-locals
if len(args) != 0 and len(kwargs) != 0:
raise ValueError('Can only specify known argument \
types either by positional or kwargs way.')
sdata = []
if len(args) != 0:
keys = c_array(ctypes.c_char_p, [])
for s in args:
if s is not None:
s = _numpy.dtype(s).type
if s not in _DTYPE_NP_TO_MX:
raise TypeError('Argument need to be one of ' + str(_DTYPE_NP_TO_MX))
sdata.append(_DTYPE_NP_TO_MX[s])
else:
sdata.append(-1)
else:
str_keys = []
for k, v in kwargs.items():
v = _numpy.dtype(v).type
if v in _DTYPE_NP_TO_MX:
str_keys.append(k)
sdata.append(_DTYPE_NP_TO_MX[v])
keys = c_str_array(str_keys)
arg_type_size = mx_uint()
arg_type_data = ctypes.POINTER(ctypes.c_int)()
out_type_size = mx_uint()
out_type_data = ctypes.POINTER(ctypes.c_int)()
aux_type_size = mx_uint()
aux_type_data = ctypes.POINTER(ctypes.c_int)()
complete = ctypes.c_int()
if partial:
infer_func = _LIB.MXSymbolInferTypePartial
else:
infer_func = _LIB.MXSymbolInferType
check_call(infer_func(
self.handle,
mx_uint(len(sdata)),
keys,
c_array_buf(ctypes.c_int, array('i', sdata)),
ctypes.byref(arg_type_size),
ctypes.byref(arg_type_data),
ctypes.byref(out_type_size),
ctypes.byref(out_type_data),
ctypes.byref(aux_type_size),
ctypes.byref(aux_type_data),
ctypes.byref(complete)))
if complete.value != 0:
arg_types = [
_DTYPE_MX_TO_NP[arg_type_data[i]] for i in range(arg_type_size.value)]
out_types = [
_DTYPE_MX_TO_NP[out_type_data[i]] for i in range(out_type_size.value)]
aux_types = [
_DTYPE_MX_TO_NP[aux_type_data[i]] for i in range(aux_type_size.value)]
return (arg_types, out_types, aux_types)
else:
return (None, None, None) | [
"def",
"_infer_type_impl",
"(",
"self",
",",
"partial",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint: disable=too-many-locals",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"and",
"len",
"(",
"kwargs",
")",
"!=",
"0",
":",
"raise",
"ValueError",
"(",
"'Can only specify known argument \\\n types either by positional or kwargs way.'",
")",
"sdata",
"=",
"[",
"]",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
":",
"keys",
"=",
"c_array",
"(",
"ctypes",
".",
"c_char_p",
",",
"[",
"]",
")",
"for",
"s",
"in",
"args",
":",
"if",
"s",
"is",
"not",
"None",
":",
"s",
"=",
"_numpy",
".",
"dtype",
"(",
"s",
")",
".",
"type",
"if",
"s",
"not",
"in",
"_DTYPE_NP_TO_MX",
":",
"raise",
"TypeError",
"(",
"'Argument need to be one of '",
"+",
"str",
"(",
"_DTYPE_NP_TO_MX",
")",
")",
"sdata",
".",
"append",
"(",
"_DTYPE_NP_TO_MX",
"[",
"s",
"]",
")",
"else",
":",
"sdata",
".",
"append",
"(",
"-",
"1",
")",
"else",
":",
"str_keys",
"=",
"[",
"]",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"v",
"=",
"_numpy",
".",
"dtype",
"(",
"v",
")",
".",
"type",
"if",
"v",
"in",
"_DTYPE_NP_TO_MX",
":",
"str_keys",
".",
"append",
"(",
"k",
")",
"sdata",
".",
"append",
"(",
"_DTYPE_NP_TO_MX",
"[",
"v",
"]",
")",
"keys",
"=",
"c_str_array",
"(",
"str_keys",
")",
"arg_type_size",
"=",
"mx_uint",
"(",
")",
"arg_type_data",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_int",
")",
"(",
")",
"out_type_size",
"=",
"mx_uint",
"(",
")",
"out_type_data",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_int",
")",
"(",
")",
"aux_type_size",
"=",
"mx_uint",
"(",
")",
"aux_type_data",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_int",
")",
"(",
")",
"complete",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"if",
"partial",
":",
"infer_func",
"=",
"_LIB",
".",
"MXSymbolInferTypePartial",
"else",
":",
"infer_func",
"=",
"_LIB",
".",
"MXSymbolInferType",
"check_call",
"(",
"infer_func",
"(",
"self",
".",
"handle",
",",
"mx_uint",
"(",
"len",
"(",
"sdata",
")",
")",
",",
"keys",
",",
"c_array_buf",
"(",
"ctypes",
".",
"c_int",
",",
"array",
"(",
"'i'",
",",
"sdata",
")",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_type_size",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_type_data",
")",
",",
"ctypes",
".",
"byref",
"(",
"out_type_size",
")",
",",
"ctypes",
".",
"byref",
"(",
"out_type_data",
")",
",",
"ctypes",
".",
"byref",
"(",
"aux_type_size",
")",
",",
"ctypes",
".",
"byref",
"(",
"aux_type_data",
")",
",",
"ctypes",
".",
"byref",
"(",
"complete",
")",
")",
")",
"if",
"complete",
".",
"value",
"!=",
"0",
":",
"arg_types",
"=",
"[",
"_DTYPE_MX_TO_NP",
"[",
"arg_type_data",
"[",
"i",
"]",
"]",
"for",
"i",
"in",
"range",
"(",
"arg_type_size",
".",
"value",
")",
"]",
"out_types",
"=",
"[",
"_DTYPE_MX_TO_NP",
"[",
"out_type_data",
"[",
"i",
"]",
"]",
"for",
"i",
"in",
"range",
"(",
"out_type_size",
".",
"value",
")",
"]",
"aux_types",
"=",
"[",
"_DTYPE_MX_TO_NP",
"[",
"aux_type_data",
"[",
"i",
"]",
"]",
"for",
"i",
"in",
"range",
"(",
"aux_type_size",
".",
"value",
")",
"]",
"return",
"(",
"arg_types",
",",
"out_types",
",",
"aux_types",
")",
"else",
":",
"return",
"(",
"None",
",",
"None",
",",
"None",
")"
] | The actual implementation for calling type inference API. | [
"The",
"actual",
"implementation",
"for",
"calling",
"type",
"inference",
"API",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L958-L1015 |
23,676 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.infer_shape | def infer_shape(self, *args, **kwargs):
"""Infers the shapes of all arguments and all outputs given the known shapes of
some arguments.
This function takes the known shapes of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing shapes.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_shapes, out_shapes, aux_shapes = c.infer_shape(a=(3,3))
>>> arg_shapes
[(3L, 3L), (3L, 3L)]
>>> out_shapes
[(3L, 3L)]
>>> aux_shapes
[]
>>> c.infer_shape(a=(0,3)) # 0s in shape means unknown dimensions. So, returns None.
(None, None, None)
Inconsistencies in the known shapes will cause an error to be raised.
See the following example:
>>> data = mx.sym.Variable('data')
>>> out = mx.sym.FullyConnected(data=data, name='fc1', num_hidden=1000)
>>> out = mx.sym.Activation(data=out, act_type='relu')
>>> out = mx.sym.FullyConnected(data=out, name='fc2', num_hidden=10)
>>> weight_shape= (1, 100)
>>> data_shape = (100, 100)
>>> out.infer_shape(data=data_shape, fc1_weight=weight_shape)
Error in operator fc1: Shape inconsistent, Provided=(1,100), inferred shape=(1000,100)
Parameters
----------
*args :
Shape of arguments in a positional way.
Unknown shape can be marked as None.
**kwargs :
Keyword arguments of the known shapes.
Returns
-------
arg_shapes : list of tuple or None
List of argument shapes.
The order is same as the order of list_arguments().
out_shapes : list of tuple or None
List of output shapes.
The order is same as the order of list_outputs().
aux_shapes : list of tuple or None
List of auxiliary state shapes.
The order is same as the order of list_auxiliary_states().
"""
try:
res = self._infer_shape_impl(False, *args, **kwargs)
if res[1] is None:
arg_shapes, _, _ = self._infer_shape_impl(True, *args, **kwargs)
arg_names = self.list_arguments()
unknowns = []
for name, shape in zip(arg_names, arg_shapes):
if is_np_compat():
shape_is_none = not shape or -1 in shape
else:
shape_is_none = not shape or 0 in shape
if shape_is_none:
if len(unknowns) >= 10:
unknowns.append('...')
break
unknowns.append('%s: %s' % (name, str(shape)))
warnings.warn(
"Cannot decide shape for the following arguments " +
"(0s in shape means unknown dimensions). " +
"Consider providing them as input:\n\t" +
"\n\t".join(unknowns), stacklevel=2)
return res
except MXNetError:
print("infer_shape error. Arguments:")
for i, arg in enumerate(args):
print(" #%d: %s" % (i, arg))
for k, v in kwargs.items():
print(" %s: %s" % (k, v))
raise | python | def infer_shape(self, *args, **kwargs):
"""Infers the shapes of all arguments and all outputs given the known shapes of
some arguments.
This function takes the known shapes of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing shapes.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_shapes, out_shapes, aux_shapes = c.infer_shape(a=(3,3))
>>> arg_shapes
[(3L, 3L), (3L, 3L)]
>>> out_shapes
[(3L, 3L)]
>>> aux_shapes
[]
>>> c.infer_shape(a=(0,3)) # 0s in shape means unknown dimensions. So, returns None.
(None, None, None)
Inconsistencies in the known shapes will cause an error to be raised.
See the following example:
>>> data = mx.sym.Variable('data')
>>> out = mx.sym.FullyConnected(data=data, name='fc1', num_hidden=1000)
>>> out = mx.sym.Activation(data=out, act_type='relu')
>>> out = mx.sym.FullyConnected(data=out, name='fc2', num_hidden=10)
>>> weight_shape= (1, 100)
>>> data_shape = (100, 100)
>>> out.infer_shape(data=data_shape, fc1_weight=weight_shape)
Error in operator fc1: Shape inconsistent, Provided=(1,100), inferred shape=(1000,100)
Parameters
----------
*args :
Shape of arguments in a positional way.
Unknown shape can be marked as None.
**kwargs :
Keyword arguments of the known shapes.
Returns
-------
arg_shapes : list of tuple or None
List of argument shapes.
The order is same as the order of list_arguments().
out_shapes : list of tuple or None
List of output shapes.
The order is same as the order of list_outputs().
aux_shapes : list of tuple or None
List of auxiliary state shapes.
The order is same as the order of list_auxiliary_states().
"""
try:
res = self._infer_shape_impl(False, *args, **kwargs)
if res[1] is None:
arg_shapes, _, _ = self._infer_shape_impl(True, *args, **kwargs)
arg_names = self.list_arguments()
unknowns = []
for name, shape in zip(arg_names, arg_shapes):
if is_np_compat():
shape_is_none = not shape or -1 in shape
else:
shape_is_none = not shape or 0 in shape
if shape_is_none:
if len(unknowns) >= 10:
unknowns.append('...')
break
unknowns.append('%s: %s' % (name, str(shape)))
warnings.warn(
"Cannot decide shape for the following arguments " +
"(0s in shape means unknown dimensions). " +
"Consider providing them as input:\n\t" +
"\n\t".join(unknowns), stacklevel=2)
return res
except MXNetError:
print("infer_shape error. Arguments:")
for i, arg in enumerate(args):
print(" #%d: %s" % (i, arg))
for k, v in kwargs.items():
print(" %s: %s" % (k, v))
raise | [
"def",
"infer_shape",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"res",
"=",
"self",
".",
"_infer_shape_impl",
"(",
"False",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"res",
"[",
"1",
"]",
"is",
"None",
":",
"arg_shapes",
",",
"_",
",",
"_",
"=",
"self",
".",
"_infer_shape_impl",
"(",
"True",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"arg_names",
"=",
"self",
".",
"list_arguments",
"(",
")",
"unknowns",
"=",
"[",
"]",
"for",
"name",
",",
"shape",
"in",
"zip",
"(",
"arg_names",
",",
"arg_shapes",
")",
":",
"if",
"is_np_compat",
"(",
")",
":",
"shape_is_none",
"=",
"not",
"shape",
"or",
"-",
"1",
"in",
"shape",
"else",
":",
"shape_is_none",
"=",
"not",
"shape",
"or",
"0",
"in",
"shape",
"if",
"shape_is_none",
":",
"if",
"len",
"(",
"unknowns",
")",
">=",
"10",
":",
"unknowns",
".",
"append",
"(",
"'...'",
")",
"break",
"unknowns",
".",
"append",
"(",
"'%s: %s'",
"%",
"(",
"name",
",",
"str",
"(",
"shape",
")",
")",
")",
"warnings",
".",
"warn",
"(",
"\"Cannot decide shape for the following arguments \"",
"+",
"\"(0s in shape means unknown dimensions). \"",
"+",
"\"Consider providing them as input:\\n\\t\"",
"+",
"\"\\n\\t\"",
".",
"join",
"(",
"unknowns",
")",
",",
"stacklevel",
"=",
"2",
")",
"return",
"res",
"except",
"MXNetError",
":",
"print",
"(",
"\"infer_shape error. Arguments:\"",
")",
"for",
"i",
",",
"arg",
"in",
"enumerate",
"(",
"args",
")",
":",
"print",
"(",
"\" #%d: %s\"",
"%",
"(",
"i",
",",
"arg",
")",
")",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"print",
"(",
"\" %s: %s\"",
"%",
"(",
"k",
",",
"v",
")",
")",
"raise"
] | Infers the shapes of all arguments and all outputs given the known shapes of
some arguments.
This function takes the known shapes of some arguments in either positional way
or keyword argument way as input. It returns a tuple of `None` values
if there is not enough information to deduce the missing shapes.
Example
-------
>>> a = mx.sym.var('a')
>>> b = mx.sym.var('b')
>>> c = a + b
>>> arg_shapes, out_shapes, aux_shapes = c.infer_shape(a=(3,3))
>>> arg_shapes
[(3L, 3L), (3L, 3L)]
>>> out_shapes
[(3L, 3L)]
>>> aux_shapes
[]
>>> c.infer_shape(a=(0,3)) # 0s in shape means unknown dimensions. So, returns None.
(None, None, None)
Inconsistencies in the known shapes will cause an error to be raised.
See the following example:
>>> data = mx.sym.Variable('data')
>>> out = mx.sym.FullyConnected(data=data, name='fc1', num_hidden=1000)
>>> out = mx.sym.Activation(data=out, act_type='relu')
>>> out = mx.sym.FullyConnected(data=out, name='fc2', num_hidden=10)
>>> weight_shape= (1, 100)
>>> data_shape = (100, 100)
>>> out.infer_shape(data=data_shape, fc1_weight=weight_shape)
Error in operator fc1: Shape inconsistent, Provided=(1,100), inferred shape=(1000,100)
Parameters
----------
*args :
Shape of arguments in a positional way.
Unknown shape can be marked as None.
**kwargs :
Keyword arguments of the known shapes.
Returns
-------
arg_shapes : list of tuple or None
List of argument shapes.
The order is same as the order of list_arguments().
out_shapes : list of tuple or None
List of output shapes.
The order is same as the order of list_outputs().
aux_shapes : list of tuple or None
List of auxiliary state shapes.
The order is same as the order of list_auxiliary_states(). | [
"Infers",
"the",
"shapes",
"of",
"all",
"arguments",
"and",
"all",
"outputs",
"given",
"the",
"known",
"shapes",
"of",
"some",
"arguments",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1018-L1102 |
23,677 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.save | def save(self, fname):
"""Saves symbol to a file.
You can also use pickle to do the job if you only work on python.
The advantage of `load`/`save` functions is that the file contents are language agnostic.
This means the model saved by one language binding can be loaded by a different
language binding of `MXNet`.
You also get the benefit of being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file.
- "s3://my-bucket/path/my-s3-symbol"
- "hdfs://my-bucket/path/my-hdfs-symbol"
- "/path-to/my-local-symbol"
See Also
--------
symbol.load : Used to load symbol from file.
"""
if not isinstance(fname, string_types):
raise TypeError('fname need to be string')
check_call(_LIB.MXSymbolSaveToFile(self.handle, c_str(fname))) | python | def save(self, fname):
"""Saves symbol to a file.
You can also use pickle to do the job if you only work on python.
The advantage of `load`/`save` functions is that the file contents are language agnostic.
This means the model saved by one language binding can be loaded by a different
language binding of `MXNet`.
You also get the benefit of being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file.
- "s3://my-bucket/path/my-s3-symbol"
- "hdfs://my-bucket/path/my-hdfs-symbol"
- "/path-to/my-local-symbol"
See Also
--------
symbol.load : Used to load symbol from file.
"""
if not isinstance(fname, string_types):
raise TypeError('fname need to be string')
check_call(_LIB.MXSymbolSaveToFile(self.handle, c_str(fname))) | [
"def",
"save",
"(",
"self",
",",
"fname",
")",
":",
"if",
"not",
"isinstance",
"(",
"fname",
",",
"string_types",
")",
":",
"raise",
"TypeError",
"(",
"'fname need to be string'",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolSaveToFile",
"(",
"self",
".",
"handle",
",",
"c_str",
"(",
"fname",
")",
")",
")"
] | Saves symbol to a file.
You can also use pickle to do the job if you only work on python.
The advantage of `load`/`save` functions is that the file contents are language agnostic.
This means the model saved by one language binding can be loaded by a different
language binding of `MXNet`.
You also get the benefit of being able to directly load/save from cloud storage(S3, HDFS).
Parameters
----------
fname : str
The name of the file.
- "s3://my-bucket/path/my-s3-symbol"
- "hdfs://my-bucket/path/my-hdfs-symbol"
- "/path-to/my-local-symbol"
See Also
--------
symbol.load : Used to load symbol from file. | [
"Saves",
"symbol",
"to",
"a",
"file",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1278-L1302 |
23,678 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.tojson | def tojson(self):
"""Saves symbol to a JSON string.
See Also
--------
symbol.load_json : Used to load symbol from JSON string.
"""
json_str = ctypes.c_char_p()
check_call(_LIB.MXSymbolSaveToJSON(self.handle, ctypes.byref(json_str)))
return py_str(json_str.value) | python | def tojson(self):
"""Saves symbol to a JSON string.
See Also
--------
symbol.load_json : Used to load symbol from JSON string.
"""
json_str = ctypes.c_char_p()
check_call(_LIB.MXSymbolSaveToJSON(self.handle, ctypes.byref(json_str)))
return py_str(json_str.value) | [
"def",
"tojson",
"(",
"self",
")",
":",
"json_str",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolSaveToJSON",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"json_str",
")",
")",
")",
"return",
"py_str",
"(",
"json_str",
".",
"value",
")"
] | Saves symbol to a JSON string.
See Also
--------
symbol.load_json : Used to load symbol from JSON string. | [
"Saves",
"symbol",
"to",
"a",
"JSON",
"string",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1304-L1313 |
23,679 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol._get_ndarray_inputs | def _get_ndarray_inputs(arg_key, args, arg_names, allow_missing):
"""Helper function to get NDArray lists handles from various inputs.
Parameters
----------
arg_key : str
The name of argument, used for error message.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbols.
If type is list of NDArray, the position is in the same order of arg_names.
If type is dict of str to NDArray, then it maps the name of arguments
to the corresponding NDArray,
args_names : list of string
List of argument names.
allow_missing : boolean
Whether missing argument is allowed.
When allowed, the missing handle will be set to None(null)
Returns
-------
handles : list of NDArrayHandle
The positional list of NDArrayHandles generated from input.
"""
# setup args
arg_handles = []
arg_arrays = []
if isinstance(args, list):
if len(args) != len(arg_names):
raise ValueError('Length of %s does not match the number of arguments' % arg_key)
for narr in args:
if narr is None and allow_missing:
arg_handles.append(None)
elif not isinstance(narr, NDArray):
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
else:
arg_handles.append(narr.handle)
arg_arrays = args
elif isinstance(args, dict):
for name in arg_names:
if name in args:
narr = args[name]
if not isinstance(narr, NDArray):
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
arg_handles.append(narr.handle)
arg_arrays.append(narr)
else:
if allow_missing:
arg_handles.append(None)
arg_arrays.append(None)
else:
raise ValueError('key `%s` is missing in `%s`' % (name, arg_key))
else:
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
return c_array(NDArrayHandle, arg_handles), arg_arrays | python | def _get_ndarray_inputs(arg_key, args, arg_names, allow_missing):
"""Helper function to get NDArray lists handles from various inputs.
Parameters
----------
arg_key : str
The name of argument, used for error message.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbols.
If type is list of NDArray, the position is in the same order of arg_names.
If type is dict of str to NDArray, then it maps the name of arguments
to the corresponding NDArray,
args_names : list of string
List of argument names.
allow_missing : boolean
Whether missing argument is allowed.
When allowed, the missing handle will be set to None(null)
Returns
-------
handles : list of NDArrayHandle
The positional list of NDArrayHandles generated from input.
"""
# setup args
arg_handles = []
arg_arrays = []
if isinstance(args, list):
if len(args) != len(arg_names):
raise ValueError('Length of %s does not match the number of arguments' % arg_key)
for narr in args:
if narr is None and allow_missing:
arg_handles.append(None)
elif not isinstance(narr, NDArray):
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
else:
arg_handles.append(narr.handle)
arg_arrays = args
elif isinstance(args, dict):
for name in arg_names:
if name in args:
narr = args[name]
if not isinstance(narr, NDArray):
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
arg_handles.append(narr.handle)
arg_arrays.append(narr)
else:
if allow_missing:
arg_handles.append(None)
arg_arrays.append(None)
else:
raise ValueError('key `%s` is missing in `%s`' % (name, arg_key))
else:
raise TypeError('Only accept list of NDArrays or dict of str to NDArray')
return c_array(NDArrayHandle, arg_handles), arg_arrays | [
"def",
"_get_ndarray_inputs",
"(",
"arg_key",
",",
"args",
",",
"arg_names",
",",
"allow_missing",
")",
":",
"# setup args",
"arg_handles",
"=",
"[",
"]",
"arg_arrays",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"args",
",",
"list",
")",
":",
"if",
"len",
"(",
"args",
")",
"!=",
"len",
"(",
"arg_names",
")",
":",
"raise",
"ValueError",
"(",
"'Length of %s does not match the number of arguments'",
"%",
"arg_key",
")",
"for",
"narr",
"in",
"args",
":",
"if",
"narr",
"is",
"None",
"and",
"allow_missing",
":",
"arg_handles",
".",
"append",
"(",
"None",
")",
"elif",
"not",
"isinstance",
"(",
"narr",
",",
"NDArray",
")",
":",
"raise",
"TypeError",
"(",
"'Only accept list of NDArrays or dict of str to NDArray'",
")",
"else",
":",
"arg_handles",
".",
"append",
"(",
"narr",
".",
"handle",
")",
"arg_arrays",
"=",
"args",
"elif",
"isinstance",
"(",
"args",
",",
"dict",
")",
":",
"for",
"name",
"in",
"arg_names",
":",
"if",
"name",
"in",
"args",
":",
"narr",
"=",
"args",
"[",
"name",
"]",
"if",
"not",
"isinstance",
"(",
"narr",
",",
"NDArray",
")",
":",
"raise",
"TypeError",
"(",
"'Only accept list of NDArrays or dict of str to NDArray'",
")",
"arg_handles",
".",
"append",
"(",
"narr",
".",
"handle",
")",
"arg_arrays",
".",
"append",
"(",
"narr",
")",
"else",
":",
"if",
"allow_missing",
":",
"arg_handles",
".",
"append",
"(",
"None",
")",
"arg_arrays",
".",
"append",
"(",
"None",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'key `%s` is missing in `%s`'",
"%",
"(",
"name",
",",
"arg_key",
")",
")",
"else",
":",
"raise",
"TypeError",
"(",
"'Only accept list of NDArrays or dict of str to NDArray'",
")",
"return",
"c_array",
"(",
"NDArrayHandle",
",",
"arg_handles",
")",
",",
"arg_arrays"
] | Helper function to get NDArray lists handles from various inputs.
Parameters
----------
arg_key : str
The name of argument, used for error message.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbols.
If type is list of NDArray, the position is in the same order of arg_names.
If type is dict of str to NDArray, then it maps the name of arguments
to the corresponding NDArray,
args_names : list of string
List of argument names.
allow_missing : boolean
Whether missing argument is allowed.
When allowed, the missing handle will be set to None(null)
Returns
-------
handles : list of NDArrayHandle
The positional list of NDArrayHandles generated from input. | [
"Helper",
"function",
"to",
"get",
"NDArray",
"lists",
"handles",
"from",
"various",
"inputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1316-L1372 |
23,680 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.bind | def bind(self, ctx, args, args_grad=None, grad_req='write',
aux_states=None, group2ctx=None, shared_exec=None):
"""Binds the current symbol to an executor and returns it.
We first declare the computation and then bind to the data to run.
This function returns an executor which provides method `forward()` method for evaluation
and a `outputs()` method to get all the results.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
<Symbol _plus1>
>>> ex = c.bind(ctx=mx.cpu(), args={'a' : mx.nd.ones([2,3]), 'b' : mx.nd.ones([2,3])})
>>> ex.forward()
[<NDArray 2x3 @cpu(0)>]
>>> ex.outputs[0].asnumpy()
[[ 2. 2. 2.]
[ 2. 2. 2.]]
Parameters
----------
ctx : Context
The device context the generated executor to run on.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbol.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding `NDArray`.
- In either case, all the arguments must be provided.
args_grad : list of NDArray or dict of str to `NDArray`, optional
When specified, `args_grad` provides NDArrays to hold
the result of gradient value in backward.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding NDArray.
- When the type is a dict of str to `NDArray`, one only need to provide the dict
for required argument gradient.
Only the specified argument gradient will be calculated.
grad_req : {'write', 'add', 'null'}, or list of str or dict of str to str, optional
To specify how we should update the gradient to the `args_grad`.
- 'write' means everytime gradient is write to specified `args_grad` `NDArray`.
- 'add' means everytime gradient is add to the specified NDArray.
- 'null' means no action is taken, the gradient may not be calculated.
aux_states : list of `NDArray`, or dict of str to `NDArray`, optional
Input auxiliary states to the symbol, only needed when the output of
`list_auxiliary_states()` is not empty.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_auxiliary_states()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of
`auxiliary_states` to the corresponding `NDArray`,
- In either case, all the auxiliary states need to be provided.
group2ctx : Dict of string to mx.Context
The dict mapping the `ctx_group` attribute to the context assignment.
shared_exec : mx.executor.Executor
Executor to share memory with. This is intended for runtime reshaping, variable length
sequences, etc. The returned executor shares state with `shared_exec`, and should not be
used in parallel with it.
Returns
-------
executor : Executor
The generated executor
Notes
-----
Auxiliary states are the special states of symbols that do not correspond
to an argument, and do not have gradient but are still useful
for the specific operations. Common examples of auxiliary states include
the `moving_mean` and `moving_variance` states in `BatchNorm`.
Most operators do not have auxiliary states and in those cases,
this parameter can be safely ignored.
One can give up gradient by using a dict in `args_grad` and only specify
gradient they interested in.
"""
# pylint: disable=too-many-locals, too-many-branches
if not isinstance(ctx, Context):
raise TypeError("Context type error")
listed_arguments = self.list_arguments()
args_handle, args = self._get_ndarray_inputs('args', args, listed_arguments, False)
# setup args gradient
if args_grad is None:
args_grad_handle = c_array(NDArrayHandle, [None] * len(args))
else:
args_grad_handle, args_grad = self._get_ndarray_inputs(
'args_grad', args_grad, listed_arguments, True)
if aux_states is None:
aux_states = []
aux_args_handle, aux_states = self._get_ndarray_inputs(
'aux_states', aux_states, self.list_auxiliary_states(), False)
# setup requirements
if isinstance(grad_req, string_types):
if grad_req not in _GRAD_REQ_MAP:
raise ValueError('grad_req must be in %s' % str(_GRAD_REQ_MAP))
reqs_array = c_array_buf(mx_uint,
array('I', [_GRAD_REQ_MAP[grad_req]] * len(listed_arguments)))
elif isinstance(grad_req, list):
reqs_array = c_array_buf(mx_uint,
array('I', [_GRAD_REQ_MAP[item] for item in grad_req]))
elif isinstance(grad_req, dict):
req_array = []
for name in listed_arguments:
if name in grad_req:
req_array.append(_GRAD_REQ_MAP[grad_req[name]])
else:
req_array.append(0)
reqs_array = c_array_buf(mx_uint, array('I', req_array))
ctx_map_keys = []
ctx_map_dev_types = []
ctx_map_dev_ids = []
if group2ctx:
for key, val in group2ctx.items():
ctx_map_keys.append(key)
ctx_map_dev_types.append(val.device_typeid)
ctx_map_dev_ids.append(val.device_id)
handle = ExecutorHandle()
shared_handle = shared_exec.handle if shared_exec is not None else ExecutorHandle()
check_call(_LIB.MXExecutorBindEX(self.handle,
ctypes.c_int(ctx.device_typeid),
ctypes.c_int(ctx.device_id),
mx_uint(len(ctx_map_keys)),
c_str_array(ctx_map_keys),
c_array_buf(ctypes.c_int, array('i', ctx_map_dev_types)),
c_array_buf(ctypes.c_int, array('i', ctx_map_dev_ids)),
mx_uint(len(args)),
args_handle,
args_grad_handle,
reqs_array,
mx_uint(len(aux_states)),
aux_args_handle,
shared_handle,
ctypes.byref(handle)))
executor = Executor(handle, self, ctx, grad_req, group2ctx)
executor.arg_arrays = args
executor.grad_arrays = args_grad
executor.aux_arrays = aux_states
return executor | python | def bind(self, ctx, args, args_grad=None, grad_req='write',
aux_states=None, group2ctx=None, shared_exec=None):
"""Binds the current symbol to an executor and returns it.
We first declare the computation and then bind to the data to run.
This function returns an executor which provides method `forward()` method for evaluation
and a `outputs()` method to get all the results.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
<Symbol _plus1>
>>> ex = c.bind(ctx=mx.cpu(), args={'a' : mx.nd.ones([2,3]), 'b' : mx.nd.ones([2,3])})
>>> ex.forward()
[<NDArray 2x3 @cpu(0)>]
>>> ex.outputs[0].asnumpy()
[[ 2. 2. 2.]
[ 2. 2. 2.]]
Parameters
----------
ctx : Context
The device context the generated executor to run on.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbol.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding `NDArray`.
- In either case, all the arguments must be provided.
args_grad : list of NDArray or dict of str to `NDArray`, optional
When specified, `args_grad` provides NDArrays to hold
the result of gradient value in backward.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding NDArray.
- When the type is a dict of str to `NDArray`, one only need to provide the dict
for required argument gradient.
Only the specified argument gradient will be calculated.
grad_req : {'write', 'add', 'null'}, or list of str or dict of str to str, optional
To specify how we should update the gradient to the `args_grad`.
- 'write' means everytime gradient is write to specified `args_grad` `NDArray`.
- 'add' means everytime gradient is add to the specified NDArray.
- 'null' means no action is taken, the gradient may not be calculated.
aux_states : list of `NDArray`, or dict of str to `NDArray`, optional
Input auxiliary states to the symbol, only needed when the output of
`list_auxiliary_states()` is not empty.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_auxiliary_states()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of
`auxiliary_states` to the corresponding `NDArray`,
- In either case, all the auxiliary states need to be provided.
group2ctx : Dict of string to mx.Context
The dict mapping the `ctx_group` attribute to the context assignment.
shared_exec : mx.executor.Executor
Executor to share memory with. This is intended for runtime reshaping, variable length
sequences, etc. The returned executor shares state with `shared_exec`, and should not be
used in parallel with it.
Returns
-------
executor : Executor
The generated executor
Notes
-----
Auxiliary states are the special states of symbols that do not correspond
to an argument, and do not have gradient but are still useful
for the specific operations. Common examples of auxiliary states include
the `moving_mean` and `moving_variance` states in `BatchNorm`.
Most operators do not have auxiliary states and in those cases,
this parameter can be safely ignored.
One can give up gradient by using a dict in `args_grad` and only specify
gradient they interested in.
"""
# pylint: disable=too-many-locals, too-many-branches
if not isinstance(ctx, Context):
raise TypeError("Context type error")
listed_arguments = self.list_arguments()
args_handle, args = self._get_ndarray_inputs('args', args, listed_arguments, False)
# setup args gradient
if args_grad is None:
args_grad_handle = c_array(NDArrayHandle, [None] * len(args))
else:
args_grad_handle, args_grad = self._get_ndarray_inputs(
'args_grad', args_grad, listed_arguments, True)
if aux_states is None:
aux_states = []
aux_args_handle, aux_states = self._get_ndarray_inputs(
'aux_states', aux_states, self.list_auxiliary_states(), False)
# setup requirements
if isinstance(grad_req, string_types):
if grad_req not in _GRAD_REQ_MAP:
raise ValueError('grad_req must be in %s' % str(_GRAD_REQ_MAP))
reqs_array = c_array_buf(mx_uint,
array('I', [_GRAD_REQ_MAP[grad_req]] * len(listed_arguments)))
elif isinstance(grad_req, list):
reqs_array = c_array_buf(mx_uint,
array('I', [_GRAD_REQ_MAP[item] for item in grad_req]))
elif isinstance(grad_req, dict):
req_array = []
for name in listed_arguments:
if name in grad_req:
req_array.append(_GRAD_REQ_MAP[grad_req[name]])
else:
req_array.append(0)
reqs_array = c_array_buf(mx_uint, array('I', req_array))
ctx_map_keys = []
ctx_map_dev_types = []
ctx_map_dev_ids = []
if group2ctx:
for key, val in group2ctx.items():
ctx_map_keys.append(key)
ctx_map_dev_types.append(val.device_typeid)
ctx_map_dev_ids.append(val.device_id)
handle = ExecutorHandle()
shared_handle = shared_exec.handle if shared_exec is not None else ExecutorHandle()
check_call(_LIB.MXExecutorBindEX(self.handle,
ctypes.c_int(ctx.device_typeid),
ctypes.c_int(ctx.device_id),
mx_uint(len(ctx_map_keys)),
c_str_array(ctx_map_keys),
c_array_buf(ctypes.c_int, array('i', ctx_map_dev_types)),
c_array_buf(ctypes.c_int, array('i', ctx_map_dev_ids)),
mx_uint(len(args)),
args_handle,
args_grad_handle,
reqs_array,
mx_uint(len(aux_states)),
aux_args_handle,
shared_handle,
ctypes.byref(handle)))
executor = Executor(handle, self, ctx, grad_req, group2ctx)
executor.arg_arrays = args
executor.grad_arrays = args_grad
executor.aux_arrays = aux_states
return executor | [
"def",
"bind",
"(",
"self",
",",
"ctx",
",",
"args",
",",
"args_grad",
"=",
"None",
",",
"grad_req",
"=",
"'write'",
",",
"aux_states",
"=",
"None",
",",
"group2ctx",
"=",
"None",
",",
"shared_exec",
"=",
"None",
")",
":",
"# pylint: disable=too-many-locals, too-many-branches",
"if",
"not",
"isinstance",
"(",
"ctx",
",",
"Context",
")",
":",
"raise",
"TypeError",
"(",
"\"Context type error\"",
")",
"listed_arguments",
"=",
"self",
".",
"list_arguments",
"(",
")",
"args_handle",
",",
"args",
"=",
"self",
".",
"_get_ndarray_inputs",
"(",
"'args'",
",",
"args",
",",
"listed_arguments",
",",
"False",
")",
"# setup args gradient",
"if",
"args_grad",
"is",
"None",
":",
"args_grad_handle",
"=",
"c_array",
"(",
"NDArrayHandle",
",",
"[",
"None",
"]",
"*",
"len",
"(",
"args",
")",
")",
"else",
":",
"args_grad_handle",
",",
"args_grad",
"=",
"self",
".",
"_get_ndarray_inputs",
"(",
"'args_grad'",
",",
"args_grad",
",",
"listed_arguments",
",",
"True",
")",
"if",
"aux_states",
"is",
"None",
":",
"aux_states",
"=",
"[",
"]",
"aux_args_handle",
",",
"aux_states",
"=",
"self",
".",
"_get_ndarray_inputs",
"(",
"'aux_states'",
",",
"aux_states",
",",
"self",
".",
"list_auxiliary_states",
"(",
")",
",",
"False",
")",
"# setup requirements",
"if",
"isinstance",
"(",
"grad_req",
",",
"string_types",
")",
":",
"if",
"grad_req",
"not",
"in",
"_GRAD_REQ_MAP",
":",
"raise",
"ValueError",
"(",
"'grad_req must be in %s'",
"%",
"str",
"(",
"_GRAD_REQ_MAP",
")",
")",
"reqs_array",
"=",
"c_array_buf",
"(",
"mx_uint",
",",
"array",
"(",
"'I'",
",",
"[",
"_GRAD_REQ_MAP",
"[",
"grad_req",
"]",
"]",
"*",
"len",
"(",
"listed_arguments",
")",
")",
")",
"elif",
"isinstance",
"(",
"grad_req",
",",
"list",
")",
":",
"reqs_array",
"=",
"c_array_buf",
"(",
"mx_uint",
",",
"array",
"(",
"'I'",
",",
"[",
"_GRAD_REQ_MAP",
"[",
"item",
"]",
"for",
"item",
"in",
"grad_req",
"]",
")",
")",
"elif",
"isinstance",
"(",
"grad_req",
",",
"dict",
")",
":",
"req_array",
"=",
"[",
"]",
"for",
"name",
"in",
"listed_arguments",
":",
"if",
"name",
"in",
"grad_req",
":",
"req_array",
".",
"append",
"(",
"_GRAD_REQ_MAP",
"[",
"grad_req",
"[",
"name",
"]",
"]",
")",
"else",
":",
"req_array",
".",
"append",
"(",
"0",
")",
"reqs_array",
"=",
"c_array_buf",
"(",
"mx_uint",
",",
"array",
"(",
"'I'",
",",
"req_array",
")",
")",
"ctx_map_keys",
"=",
"[",
"]",
"ctx_map_dev_types",
"=",
"[",
"]",
"ctx_map_dev_ids",
"=",
"[",
"]",
"if",
"group2ctx",
":",
"for",
"key",
",",
"val",
"in",
"group2ctx",
".",
"items",
"(",
")",
":",
"ctx_map_keys",
".",
"append",
"(",
"key",
")",
"ctx_map_dev_types",
".",
"append",
"(",
"val",
".",
"device_typeid",
")",
"ctx_map_dev_ids",
".",
"append",
"(",
"val",
".",
"device_id",
")",
"handle",
"=",
"ExecutorHandle",
"(",
")",
"shared_handle",
"=",
"shared_exec",
".",
"handle",
"if",
"shared_exec",
"is",
"not",
"None",
"else",
"ExecutorHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXExecutorBindEX",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"c_int",
"(",
"ctx",
".",
"device_typeid",
")",
",",
"ctypes",
".",
"c_int",
"(",
"ctx",
".",
"device_id",
")",
",",
"mx_uint",
"(",
"len",
"(",
"ctx_map_keys",
")",
")",
",",
"c_str_array",
"(",
"ctx_map_keys",
")",
",",
"c_array_buf",
"(",
"ctypes",
".",
"c_int",
",",
"array",
"(",
"'i'",
",",
"ctx_map_dev_types",
")",
")",
",",
"c_array_buf",
"(",
"ctypes",
".",
"c_int",
",",
"array",
"(",
"'i'",
",",
"ctx_map_dev_ids",
")",
")",
",",
"mx_uint",
"(",
"len",
"(",
"args",
")",
")",
",",
"args_handle",
",",
"args_grad_handle",
",",
"reqs_array",
",",
"mx_uint",
"(",
"len",
"(",
"aux_states",
")",
")",
",",
"aux_args_handle",
",",
"shared_handle",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"executor",
"=",
"Executor",
"(",
"handle",
",",
"self",
",",
"ctx",
",",
"grad_req",
",",
"group2ctx",
")",
"executor",
".",
"arg_arrays",
"=",
"args",
"executor",
".",
"grad_arrays",
"=",
"args_grad",
"executor",
".",
"aux_arrays",
"=",
"aux_states",
"return",
"executor"
] | Binds the current symbol to an executor and returns it.
We first declare the computation and then bind to the data to run.
This function returns an executor which provides method `forward()` method for evaluation
and a `outputs()` method to get all the results.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
<Symbol _plus1>
>>> ex = c.bind(ctx=mx.cpu(), args={'a' : mx.nd.ones([2,3]), 'b' : mx.nd.ones([2,3])})
>>> ex.forward()
[<NDArray 2x3 @cpu(0)>]
>>> ex.outputs[0].asnumpy()
[[ 2. 2. 2.]
[ 2. 2. 2.]]
Parameters
----------
ctx : Context
The device context the generated executor to run on.
args : list of NDArray or dict of str to NDArray
Input arguments to the symbol.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding `NDArray`.
- In either case, all the arguments must be provided.
args_grad : list of NDArray or dict of str to `NDArray`, optional
When specified, `args_grad` provides NDArrays to hold
the result of gradient value in backward.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_arguments()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of arguments
to the corresponding NDArray.
- When the type is a dict of str to `NDArray`, one only need to provide the dict
for required argument gradient.
Only the specified argument gradient will be calculated.
grad_req : {'write', 'add', 'null'}, or list of str or dict of str to str, optional
To specify how we should update the gradient to the `args_grad`.
- 'write' means everytime gradient is write to specified `args_grad` `NDArray`.
- 'add' means everytime gradient is add to the specified NDArray.
- 'null' means no action is taken, the gradient may not be calculated.
aux_states : list of `NDArray`, or dict of str to `NDArray`, optional
Input auxiliary states to the symbol, only needed when the output of
`list_auxiliary_states()` is not empty.
- If the input type is a list of `NDArray`, the order should be same as the order
of `list_auxiliary_states()`.
- If the input type is a dict of str to `NDArray`, then it maps the name of
`auxiliary_states` to the corresponding `NDArray`,
- In either case, all the auxiliary states need to be provided.
group2ctx : Dict of string to mx.Context
The dict mapping the `ctx_group` attribute to the context assignment.
shared_exec : mx.executor.Executor
Executor to share memory with. This is intended for runtime reshaping, variable length
sequences, etc. The returned executor shares state with `shared_exec`, and should not be
used in parallel with it.
Returns
-------
executor : Executor
The generated executor
Notes
-----
Auxiliary states are the special states of symbols that do not correspond
to an argument, and do not have gradient but are still useful
for the specific operations. Common examples of auxiliary states include
the `moving_mean` and `moving_variance` states in `BatchNorm`.
Most operators do not have auxiliary states and in those cases,
this parameter can be safely ignored.
One can give up gradient by using a dict in `args_grad` and only specify
gradient they interested in. | [
"Binds",
"the",
"current",
"symbol",
"to",
"an",
"executor",
"and",
"returns",
"it",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1639-L1795 |
23,681 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.gradient | def gradient(self, wrt):
"""Gets the autodiff of current symbol.
This function can only be used if current symbol is a loss function.
.. note:: This function is currently not implemented.
Parameters
----------
wrt : Array of String
keyword arguments of the symbol that the gradients are taken.
Returns
-------
grad : Symbol
A gradient Symbol with returns to be the corresponding gradients.
"""
handle = SymbolHandle()
c_wrt = c_str_array(wrt)
check_call(_LIB.MXSymbolGrad(self.handle,
mx_uint(len(wrt)),
c_wrt,
ctypes.byref(handle)))
return Symbol(handle) | python | def gradient(self, wrt):
"""Gets the autodiff of current symbol.
This function can only be used if current symbol is a loss function.
.. note:: This function is currently not implemented.
Parameters
----------
wrt : Array of String
keyword arguments of the symbol that the gradients are taken.
Returns
-------
grad : Symbol
A gradient Symbol with returns to be the corresponding gradients.
"""
handle = SymbolHandle()
c_wrt = c_str_array(wrt)
check_call(_LIB.MXSymbolGrad(self.handle,
mx_uint(len(wrt)),
c_wrt,
ctypes.byref(handle)))
return Symbol(handle) | [
"def",
"gradient",
"(",
"self",
",",
"wrt",
")",
":",
"handle",
"=",
"SymbolHandle",
"(",
")",
"c_wrt",
"=",
"c_str_array",
"(",
"wrt",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolGrad",
"(",
"self",
".",
"handle",
",",
"mx_uint",
"(",
"len",
"(",
"wrt",
")",
")",
",",
"c_wrt",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
")",
")",
"return",
"Symbol",
"(",
"handle",
")"
] | Gets the autodiff of current symbol.
This function can only be used if current symbol is a loss function.
.. note:: This function is currently not implemented.
Parameters
----------
wrt : Array of String
keyword arguments of the symbol that the gradients are taken.
Returns
-------
grad : Symbol
A gradient Symbol with returns to be the corresponding gradients. | [
"Gets",
"the",
"autodiff",
"of",
"current",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1797-L1820 |
23,682 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.eval | def eval(self, ctx=None, **kwargs):
"""Evaluates a symbol given arguments.
The `eval` method combines a call to `bind` (which returns an executor)
with a call to `forward` (executor method).
For the common use case, where you might repeatedly evaluate with same arguments,
eval is slow.
In that case, you should call `bind` once and then repeatedly call forward.
This function allows simpler syntax for less cumbersome introspection.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
>>> ex = c.eval(ctx = mx.cpu(), a = mx.nd.ones([2,3]), b = mx.nd.ones([2,3]))
>>> ex
[<NDArray 2x3 @cpu(0)>]
>>> ex[0].asnumpy()
array([[ 2., 2., 2.],
[ 2., 2., 2.]], dtype=float32)
Parameters
----------
ctx : Context
The device context the generated executor to run on.
kwargs : Keyword arguments of type `NDArray`
Input arguments to the symbol. All the arguments must be provided.
Returns
----------
result : a list of NDArrays corresponding to the values taken by each symbol when
evaluated on given args. When called on a single symbol (not a group),
the result will be a list with one element.
"""
if ctx is None:
ctx = current_context()
return self.bind(ctx, kwargs).forward() | python | def eval(self, ctx=None, **kwargs):
"""Evaluates a symbol given arguments.
The `eval` method combines a call to `bind` (which returns an executor)
with a call to `forward` (executor method).
For the common use case, where you might repeatedly evaluate with same arguments,
eval is slow.
In that case, you should call `bind` once and then repeatedly call forward.
This function allows simpler syntax for less cumbersome introspection.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
>>> ex = c.eval(ctx = mx.cpu(), a = mx.nd.ones([2,3]), b = mx.nd.ones([2,3]))
>>> ex
[<NDArray 2x3 @cpu(0)>]
>>> ex[0].asnumpy()
array([[ 2., 2., 2.],
[ 2., 2., 2.]], dtype=float32)
Parameters
----------
ctx : Context
The device context the generated executor to run on.
kwargs : Keyword arguments of type `NDArray`
Input arguments to the symbol. All the arguments must be provided.
Returns
----------
result : a list of NDArrays corresponding to the values taken by each symbol when
evaluated on given args. When called on a single symbol (not a group),
the result will be a list with one element.
"""
if ctx is None:
ctx = current_context()
return self.bind(ctx, kwargs).forward() | [
"def",
"eval",
"(",
"self",
",",
"ctx",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"current_context",
"(",
")",
"return",
"self",
".",
"bind",
"(",
"ctx",
",",
"kwargs",
")",
".",
"forward",
"(",
")"
] | Evaluates a symbol given arguments.
The `eval` method combines a call to `bind` (which returns an executor)
with a call to `forward` (executor method).
For the common use case, where you might repeatedly evaluate with same arguments,
eval is slow.
In that case, you should call `bind` once and then repeatedly call forward.
This function allows simpler syntax for less cumbersome introspection.
Example
-------
>>> a = mx.sym.Variable('a')
>>> b = mx.sym.Variable('b')
>>> c = a + b
>>> ex = c.eval(ctx = mx.cpu(), a = mx.nd.ones([2,3]), b = mx.nd.ones([2,3]))
>>> ex
[<NDArray 2x3 @cpu(0)>]
>>> ex[0].asnumpy()
array([[ 2., 2., 2.],
[ 2., 2., 2.]], dtype=float32)
Parameters
----------
ctx : Context
The device context the generated executor to run on.
kwargs : Keyword arguments of type `NDArray`
Input arguments to the symbol. All the arguments must be provided.
Returns
----------
result : a list of NDArrays corresponding to the values taken by each symbol when
evaluated on given args. When called on a single symbol (not a group),
the result will be a list with one element. | [
"Evaluates",
"a",
"symbol",
"given",
"arguments",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L1824-L1862 |
23,683 | apache/incubator-mxnet | python/mxnet/symbol/symbol.py | Symbol.get_backend_symbol | def get_backend_symbol(self, backend):
"""Return symbol for target backend.
Parameters
----------
backend : str
The backend names.
Returns
-------
out : Symbol
The created Symbol for target backend.
"""
out = SymbolHandle()
check_call(_LIB.MXGenBackendSubgraph(self.handle, c_str(backend), ctypes.byref(out)))
return Symbol(out) | python | def get_backend_symbol(self, backend):
"""Return symbol for target backend.
Parameters
----------
backend : str
The backend names.
Returns
-------
out : Symbol
The created Symbol for target backend.
"""
out = SymbolHandle()
check_call(_LIB.MXGenBackendSubgraph(self.handle, c_str(backend), ctypes.byref(out)))
return Symbol(out) | [
"def",
"get_backend_symbol",
"(",
"self",
",",
"backend",
")",
":",
"out",
"=",
"SymbolHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXGenBackendSubgraph",
"(",
"self",
".",
"handle",
",",
"c_str",
"(",
"backend",
")",
",",
"ctypes",
".",
"byref",
"(",
"out",
")",
")",
")",
"return",
"Symbol",
"(",
"out",
")"
] | Return symbol for target backend.
Parameters
----------
backend : str
The backend names.
Returns
-------
out : Symbol
The created Symbol for target backend. | [
"Return",
"symbol",
"for",
"target",
"backend",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/symbol.py#L2536-L2551 |
23,684 | apache/incubator-mxnet | tools/coreml/converter/utils.py | load_model | def load_model(model_name, epoch_num, data_shapes, label_shapes, label_names, gpus=''):
"""Returns a module loaded with the provided model.
Parameters
----------
model_name: str
Prefix of the MXNet model name as stored on the local directory.
epoch_num : int
Epoch number of model we would like to load.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module
"""
sym, arg_params, aux_params = mx.model.load_checkpoint(model_name, epoch_num)
mod = create_module(sym, data_shapes, label_shapes, label_names, gpus)
mod.set_params(
arg_params=arg_params,
aux_params=aux_params,
allow_missing=True
)
return mod | python | def load_model(model_name, epoch_num, data_shapes, label_shapes, label_names, gpus=''):
"""Returns a module loaded with the provided model.
Parameters
----------
model_name: str
Prefix of the MXNet model name as stored on the local directory.
epoch_num : int
Epoch number of model we would like to load.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module
"""
sym, arg_params, aux_params = mx.model.load_checkpoint(model_name, epoch_num)
mod = create_module(sym, data_shapes, label_shapes, label_names, gpus)
mod.set_params(
arg_params=arg_params,
aux_params=aux_params,
allow_missing=True
)
return mod | [
"def",
"load_model",
"(",
"model_name",
",",
"epoch_num",
",",
"data_shapes",
",",
"label_shapes",
",",
"label_names",
",",
"gpus",
"=",
"''",
")",
":",
"sym",
",",
"arg_params",
",",
"aux_params",
"=",
"mx",
".",
"model",
".",
"load_checkpoint",
"(",
"model_name",
",",
"epoch_num",
")",
"mod",
"=",
"create_module",
"(",
"sym",
",",
"data_shapes",
",",
"label_shapes",
",",
"label_names",
",",
"gpus",
")",
"mod",
".",
"set_params",
"(",
"arg_params",
"=",
"arg_params",
",",
"aux_params",
"=",
"aux_params",
",",
"allow_missing",
"=",
"True",
")",
"return",
"mod"
] | Returns a module loaded with the provided model.
Parameters
----------
model_name: str
Prefix of the MXNet model name as stored on the local directory.
epoch_num : int
Epoch number of model we would like to load.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module | [
"Returns",
"a",
"module",
"loaded",
"with",
"the",
"provided",
"model",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/tools/coreml/converter/utils.py#L21-L65 |
23,685 | apache/incubator-mxnet | tools/coreml/converter/utils.py | create_module | def create_module(sym, data_shapes, label_shapes, label_names, gpus=''):
"""Creates a new MXNet module.
Parameters
----------
sym : Symbol
An MXNet symbol.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module
"""
if gpus == '':
devices = mx.cpu()
else:
devices = [mx.gpu(int(i)) for i in gpus.split(',')]
data_names = [data_shape[0] for data_shape in data_shapes]
mod = mx.mod.Module(
symbol=sym,
data_names=data_names,
context=devices,
label_names=label_names
)
mod.bind(
for_training=False,
data_shapes=data_shapes,
label_shapes=label_shapes
)
return mod | python | def create_module(sym, data_shapes, label_shapes, label_names, gpus=''):
"""Creates a new MXNet module.
Parameters
----------
sym : Symbol
An MXNet symbol.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module
"""
if gpus == '':
devices = mx.cpu()
else:
devices = [mx.gpu(int(i)) for i in gpus.split(',')]
data_names = [data_shape[0] for data_shape in data_shapes]
mod = mx.mod.Module(
symbol=sym,
data_names=data_names,
context=devices,
label_names=label_names
)
mod.bind(
for_training=False,
data_shapes=data_shapes,
label_shapes=label_shapes
)
return mod | [
"def",
"create_module",
"(",
"sym",
",",
"data_shapes",
",",
"label_shapes",
",",
"label_names",
",",
"gpus",
"=",
"''",
")",
":",
"if",
"gpus",
"==",
"''",
":",
"devices",
"=",
"mx",
".",
"cpu",
"(",
")",
"else",
":",
"devices",
"=",
"[",
"mx",
".",
"gpu",
"(",
"int",
"(",
"i",
")",
")",
"for",
"i",
"in",
"gpus",
".",
"split",
"(",
"','",
")",
"]",
"data_names",
"=",
"[",
"data_shape",
"[",
"0",
"]",
"for",
"data_shape",
"in",
"data_shapes",
"]",
"mod",
"=",
"mx",
".",
"mod",
".",
"Module",
"(",
"symbol",
"=",
"sym",
",",
"data_names",
"=",
"data_names",
",",
"context",
"=",
"devices",
",",
"label_names",
"=",
"label_names",
")",
"mod",
".",
"bind",
"(",
"for_training",
"=",
"False",
",",
"data_shapes",
"=",
"data_shapes",
",",
"label_shapes",
"=",
"label_shapes",
")",
"return",
"mod"
] | Creates a new MXNet module.
Parameters
----------
sym : Symbol
An MXNet symbol.
input_shape: tuple
The shape of the input data in the form of (batch_size, channels, height, width)
files: list of strings
List of URLs pertaining to files that need to be downloaded in order to use the model.
data_shapes: list of tuples.
List of tuples where each tuple is a pair of input variable name and its shape.
label_shapes: list of (str, tuple)
Typically is ``data_iter.provide_label``.
label_names: list of str
Name of the output labels in the MXNet symbolic graph.
gpus: str
Comma separated string of gpu ids on which inferences are executed. E.g. 3,5,6 would refer to GPUs 3, 5 and 6.
If empty, we use CPU.
Returns
-------
MXNet module | [
"Creates",
"a",
"new",
"MXNet",
"module",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/tools/coreml/converter/utils.py#L68-L117 |
23,686 | apache/incubator-mxnet | example/ssd/evaluate/evaluate_net.py | evaluate_net | def evaluate_net(net, path_imgrec, num_classes, num_batch, mean_pixels, data_shape,
model_prefix, epoch, ctx=mx.cpu(), batch_size=32,
path_imglist="", nms_thresh=0.45, force_nms=False,
ovp_thresh=0.5, use_difficult=False, class_names=None,
voc07_metric=False):
"""
evalute network given validation record file
Parameters:
----------
net : str or None
Network name or use None to load from json without modifying
path_imgrec : str
path to the record validation file
path_imglist : str
path to the list file to replace labels in record file, optional
num_classes : int
number of classes, not including background
mean_pixels : tuple
(mean_r, mean_g, mean_b)
data_shape : tuple or int
(3, height, width) or height/width
model_prefix : str
model prefix of saved checkpoint
epoch : int
load model epoch
ctx : mx.ctx
mx.gpu() or mx.cpu()
batch_size : int
validation batch size
nms_thresh : float
non-maximum suppression threshold
force_nms : boolean
whether suppress different class objects
ovp_thresh : float
AP overlap threshold for true/false postives
use_difficult : boolean
whether to use difficult objects in evaluation if applicable
class_names : comma separated str
class names in string, must correspond to num_classes if set
voc07_metric : boolean
whether to use 11-point evluation as in VOC07 competition
"""
# set up logger
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# args
if isinstance(data_shape, int):
data_shape = (3, data_shape, data_shape)
assert len(data_shape) == 3 and data_shape[0] == 3
model_prefix += '_' + str(data_shape[1])
# iterator
eval_iter = DetRecordIter(path_imgrec, batch_size, data_shape, mean_pixels=mean_pixels,
path_imglist=path_imglist, **cfg.valid)
# model params
load_net, args, auxs = mx.model.load_checkpoint(model_prefix, epoch)
# network
if net is None:
net = load_net
else:
net = get_symbol(net, data_shape[1], num_classes=num_classes,
nms_thresh=nms_thresh, force_suppress=force_nms)
if not 'label' in net.list_arguments():
label = mx.sym.Variable(name='label')
net = mx.sym.Group([net, label])
# init module
mod = mx.mod.Module(net, label_names=('label',), logger=logger, context=ctx,
fixed_param_names=net.list_arguments())
mod.bind(data_shapes=eval_iter.provide_data, label_shapes=eval_iter.provide_label)
mod.set_params(args, auxs, allow_missing=False, force_init=True)
# run evaluation
if voc07_metric:
metric = VOC07MApMetric(ovp_thresh, use_difficult, class_names)
else:
metric = MApMetric(ovp_thresh, use_difficult, class_names)
num = num_batch * batch_size
data = [mx.random.uniform(-1.0, 1.0, shape=shape, ctx=ctx) for _, shape in mod.data_shapes]
batch = mx.io.DataBatch(data, []) # empty label
dry_run = 5 # use 5 iterations to warm up
for i in range(dry_run):
mod.forward(batch, is_train=False)
for output in mod.get_outputs():
output.wait_to_read()
tic = time.time()
results = mod.score(eval_iter, metric, num_batch=num_batch)
speed = num / (time.time() - tic)
if logger is not None:
logger.info('Finished inference with %d images' % num)
logger.info('Finished with %f images per second', speed)
for k, v in results:
print("{}: {}".format(k, v)) | python | def evaluate_net(net, path_imgrec, num_classes, num_batch, mean_pixels, data_shape,
model_prefix, epoch, ctx=mx.cpu(), batch_size=32,
path_imglist="", nms_thresh=0.45, force_nms=False,
ovp_thresh=0.5, use_difficult=False, class_names=None,
voc07_metric=False):
"""
evalute network given validation record file
Parameters:
----------
net : str or None
Network name or use None to load from json without modifying
path_imgrec : str
path to the record validation file
path_imglist : str
path to the list file to replace labels in record file, optional
num_classes : int
number of classes, not including background
mean_pixels : tuple
(mean_r, mean_g, mean_b)
data_shape : tuple or int
(3, height, width) or height/width
model_prefix : str
model prefix of saved checkpoint
epoch : int
load model epoch
ctx : mx.ctx
mx.gpu() or mx.cpu()
batch_size : int
validation batch size
nms_thresh : float
non-maximum suppression threshold
force_nms : boolean
whether suppress different class objects
ovp_thresh : float
AP overlap threshold for true/false postives
use_difficult : boolean
whether to use difficult objects in evaluation if applicable
class_names : comma separated str
class names in string, must correspond to num_classes if set
voc07_metric : boolean
whether to use 11-point evluation as in VOC07 competition
"""
# set up logger
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# args
if isinstance(data_shape, int):
data_shape = (3, data_shape, data_shape)
assert len(data_shape) == 3 and data_shape[0] == 3
model_prefix += '_' + str(data_shape[1])
# iterator
eval_iter = DetRecordIter(path_imgrec, batch_size, data_shape, mean_pixels=mean_pixels,
path_imglist=path_imglist, **cfg.valid)
# model params
load_net, args, auxs = mx.model.load_checkpoint(model_prefix, epoch)
# network
if net is None:
net = load_net
else:
net = get_symbol(net, data_shape[1], num_classes=num_classes,
nms_thresh=nms_thresh, force_suppress=force_nms)
if not 'label' in net.list_arguments():
label = mx.sym.Variable(name='label')
net = mx.sym.Group([net, label])
# init module
mod = mx.mod.Module(net, label_names=('label',), logger=logger, context=ctx,
fixed_param_names=net.list_arguments())
mod.bind(data_shapes=eval_iter.provide_data, label_shapes=eval_iter.provide_label)
mod.set_params(args, auxs, allow_missing=False, force_init=True)
# run evaluation
if voc07_metric:
metric = VOC07MApMetric(ovp_thresh, use_difficult, class_names)
else:
metric = MApMetric(ovp_thresh, use_difficult, class_names)
num = num_batch * batch_size
data = [mx.random.uniform(-1.0, 1.0, shape=shape, ctx=ctx) for _, shape in mod.data_shapes]
batch = mx.io.DataBatch(data, []) # empty label
dry_run = 5 # use 5 iterations to warm up
for i in range(dry_run):
mod.forward(batch, is_train=False)
for output in mod.get_outputs():
output.wait_to_read()
tic = time.time()
results = mod.score(eval_iter, metric, num_batch=num_batch)
speed = num / (time.time() - tic)
if logger is not None:
logger.info('Finished inference with %d images' % num)
logger.info('Finished with %f images per second', speed)
for k, v in results:
print("{}: {}".format(k, v)) | [
"def",
"evaluate_net",
"(",
"net",
",",
"path_imgrec",
",",
"num_classes",
",",
"num_batch",
",",
"mean_pixels",
",",
"data_shape",
",",
"model_prefix",
",",
"epoch",
",",
"ctx",
"=",
"mx",
".",
"cpu",
"(",
")",
",",
"batch_size",
"=",
"32",
",",
"path_imglist",
"=",
"\"\"",
",",
"nms_thresh",
"=",
"0.45",
",",
"force_nms",
"=",
"False",
",",
"ovp_thresh",
"=",
"0.5",
",",
"use_difficult",
"=",
"False",
",",
"class_names",
"=",
"None",
",",
"voc07_metric",
"=",
"False",
")",
":",
"# set up logger",
"logging",
".",
"basicConfig",
"(",
")",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"logger",
".",
"setLevel",
"(",
"logging",
".",
"INFO",
")",
"# args",
"if",
"isinstance",
"(",
"data_shape",
",",
"int",
")",
":",
"data_shape",
"=",
"(",
"3",
",",
"data_shape",
",",
"data_shape",
")",
"assert",
"len",
"(",
"data_shape",
")",
"==",
"3",
"and",
"data_shape",
"[",
"0",
"]",
"==",
"3",
"model_prefix",
"+=",
"'_'",
"+",
"str",
"(",
"data_shape",
"[",
"1",
"]",
")",
"# iterator",
"eval_iter",
"=",
"DetRecordIter",
"(",
"path_imgrec",
",",
"batch_size",
",",
"data_shape",
",",
"mean_pixels",
"=",
"mean_pixels",
",",
"path_imglist",
"=",
"path_imglist",
",",
"*",
"*",
"cfg",
".",
"valid",
")",
"# model params",
"load_net",
",",
"args",
",",
"auxs",
"=",
"mx",
".",
"model",
".",
"load_checkpoint",
"(",
"model_prefix",
",",
"epoch",
")",
"# network",
"if",
"net",
"is",
"None",
":",
"net",
"=",
"load_net",
"else",
":",
"net",
"=",
"get_symbol",
"(",
"net",
",",
"data_shape",
"[",
"1",
"]",
",",
"num_classes",
"=",
"num_classes",
",",
"nms_thresh",
"=",
"nms_thresh",
",",
"force_suppress",
"=",
"force_nms",
")",
"if",
"not",
"'label'",
"in",
"net",
".",
"list_arguments",
"(",
")",
":",
"label",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"name",
"=",
"'label'",
")",
"net",
"=",
"mx",
".",
"sym",
".",
"Group",
"(",
"[",
"net",
",",
"label",
"]",
")",
"# init module",
"mod",
"=",
"mx",
".",
"mod",
".",
"Module",
"(",
"net",
",",
"label_names",
"=",
"(",
"'label'",
",",
")",
",",
"logger",
"=",
"logger",
",",
"context",
"=",
"ctx",
",",
"fixed_param_names",
"=",
"net",
".",
"list_arguments",
"(",
")",
")",
"mod",
".",
"bind",
"(",
"data_shapes",
"=",
"eval_iter",
".",
"provide_data",
",",
"label_shapes",
"=",
"eval_iter",
".",
"provide_label",
")",
"mod",
".",
"set_params",
"(",
"args",
",",
"auxs",
",",
"allow_missing",
"=",
"False",
",",
"force_init",
"=",
"True",
")",
"# run evaluation",
"if",
"voc07_metric",
":",
"metric",
"=",
"VOC07MApMetric",
"(",
"ovp_thresh",
",",
"use_difficult",
",",
"class_names",
")",
"else",
":",
"metric",
"=",
"MApMetric",
"(",
"ovp_thresh",
",",
"use_difficult",
",",
"class_names",
")",
"num",
"=",
"num_batch",
"*",
"batch_size",
"data",
"=",
"[",
"mx",
".",
"random",
".",
"uniform",
"(",
"-",
"1.0",
",",
"1.0",
",",
"shape",
"=",
"shape",
",",
"ctx",
"=",
"ctx",
")",
"for",
"_",
",",
"shape",
"in",
"mod",
".",
"data_shapes",
"]",
"batch",
"=",
"mx",
".",
"io",
".",
"DataBatch",
"(",
"data",
",",
"[",
"]",
")",
"# empty label",
"dry_run",
"=",
"5",
"# use 5 iterations to warm up",
"for",
"i",
"in",
"range",
"(",
"dry_run",
")",
":",
"mod",
".",
"forward",
"(",
"batch",
",",
"is_train",
"=",
"False",
")",
"for",
"output",
"in",
"mod",
".",
"get_outputs",
"(",
")",
":",
"output",
".",
"wait_to_read",
"(",
")",
"tic",
"=",
"time",
".",
"time",
"(",
")",
"results",
"=",
"mod",
".",
"score",
"(",
"eval_iter",
",",
"metric",
",",
"num_batch",
"=",
"num_batch",
")",
"speed",
"=",
"num",
"/",
"(",
"time",
".",
"time",
"(",
")",
"-",
"tic",
")",
"if",
"logger",
"is",
"not",
"None",
":",
"logger",
".",
"info",
"(",
"'Finished inference with %d images'",
"%",
"num",
")",
"logger",
".",
"info",
"(",
"'Finished with %f images per second'",
",",
"speed",
")",
"for",
"k",
",",
"v",
"in",
"results",
":",
"print",
"(",
"\"{}: {}\"",
".",
"format",
"(",
"k",
",",
"v",
")",
")"
] | evalute network given validation record file
Parameters:
----------
net : str or None
Network name or use None to load from json without modifying
path_imgrec : str
path to the record validation file
path_imglist : str
path to the list file to replace labels in record file, optional
num_classes : int
number of classes, not including background
mean_pixels : tuple
(mean_r, mean_g, mean_b)
data_shape : tuple or int
(3, height, width) or height/width
model_prefix : str
model prefix of saved checkpoint
epoch : int
load model epoch
ctx : mx.ctx
mx.gpu() or mx.cpu()
batch_size : int
validation batch size
nms_thresh : float
non-maximum suppression threshold
force_nms : boolean
whether suppress different class objects
ovp_thresh : float
AP overlap threshold for true/false postives
use_difficult : boolean
whether to use difficult objects in evaluation if applicable
class_names : comma separated str
class names in string, must correspond to num_classes if set
voc07_metric : boolean
whether to use 11-point evluation as in VOC07 competition | [
"evalute",
"network",
"given",
"validation",
"record",
"file"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/evaluate/evaluate_net.py#L34-L133 |
23,687 | apache/incubator-mxnet | python/mxnet/module/python_module.py | PythonModule.init_params | def init_params(self, initializer=Uniform(0.01), arg_params=None, aux_params=None,
allow_missing=False, force_init=False, allow_extra=False):
"""Initializes the parameters and auxiliary states. By default this function
does nothing. Subclass should override this method if contains parameters.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing `arg_params`. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing `aux_params`. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor.
"""
pass | python | def init_params(self, initializer=Uniform(0.01), arg_params=None, aux_params=None,
allow_missing=False, force_init=False, allow_extra=False):
"""Initializes the parameters and auxiliary states. By default this function
does nothing. Subclass should override this method if contains parameters.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing `arg_params`. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing `aux_params`. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor.
"""
pass | [
"def",
"init_params",
"(",
"self",
",",
"initializer",
"=",
"Uniform",
"(",
"0.01",
")",
",",
"arg_params",
"=",
"None",
",",
"aux_params",
"=",
"None",
",",
"allow_missing",
"=",
"False",
",",
"force_init",
"=",
"False",
",",
"allow_extra",
"=",
"False",
")",
":",
"pass"
] | Initializes the parameters and auxiliary states. By default this function
does nothing. Subclass should override this method if contains parameters.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing `arg_params`. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing `aux_params`. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor. | [
"Initializes",
"the",
"parameters",
"and",
"auxiliary",
"states",
".",
"By",
"default",
"this",
"function",
"does",
"nothing",
".",
"Subclass",
"should",
"override",
"this",
"method",
"if",
"contains",
"parameters",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/python_module.py#L107-L132 |
23,688 | apache/incubator-mxnet | python/mxnet/module/python_module.py | PythonModule.update_metric | def update_metric(self, eval_metric, labels, pre_sliced=False):
"""Evaluates and accumulates evaluation metric on outputs of the last forward computation.
Subclass should override this method if needed.
Parameters
----------
eval_metric : EvalMetric
labels : list of NDArray
Typically ``data_batch.label``.
"""
if self._label_shapes is None:
# since we do not need labels, we are probably not a module with a loss
# function or predictions, so just ignore this call
return
if pre_sliced:
raise RuntimeError("PythonModule does not support presliced labels")
# by default we expect our outputs are some scores that could be evaluated
eval_metric.update(labels, self.get_outputs()) | python | def update_metric(self, eval_metric, labels, pre_sliced=False):
"""Evaluates and accumulates evaluation metric on outputs of the last forward computation.
Subclass should override this method if needed.
Parameters
----------
eval_metric : EvalMetric
labels : list of NDArray
Typically ``data_batch.label``.
"""
if self._label_shapes is None:
# since we do not need labels, we are probably not a module with a loss
# function or predictions, so just ignore this call
return
if pre_sliced:
raise RuntimeError("PythonModule does not support presliced labels")
# by default we expect our outputs are some scores that could be evaluated
eval_metric.update(labels, self.get_outputs()) | [
"def",
"update_metric",
"(",
"self",
",",
"eval_metric",
",",
"labels",
",",
"pre_sliced",
"=",
"False",
")",
":",
"if",
"self",
".",
"_label_shapes",
"is",
"None",
":",
"# since we do not need labels, we are probably not a module with a loss",
"# function or predictions, so just ignore this call",
"return",
"if",
"pre_sliced",
":",
"raise",
"RuntimeError",
"(",
"\"PythonModule does not support presliced labels\"",
")",
"# by default we expect our outputs are some scores that could be evaluated",
"eval_metric",
".",
"update",
"(",
"labels",
",",
"self",
".",
"get_outputs",
"(",
")",
")"
] | Evaluates and accumulates evaluation metric on outputs of the last forward computation.
Subclass should override this method if needed.
Parameters
----------
eval_metric : EvalMetric
labels : list of NDArray
Typically ``data_batch.label``. | [
"Evaluates",
"and",
"accumulates",
"evaluation",
"metric",
"on",
"outputs",
"of",
"the",
"last",
"forward",
"computation",
".",
"Subclass",
"should",
"override",
"this",
"method",
"if",
"needed",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/python_module.py#L141-L160 |
23,689 | apache/incubator-mxnet | python/mxnet/module/python_module.py | PythonLossModule.forward | def forward(self, data_batch, is_train=None):
"""Forward computation. Here we do nothing but to keep a reference to
the scores and the labels so that we can do backward computation.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means `is_train` takes the value of ``self.for_training``.
"""
self._scores = data_batch.data[0]
if is_train is None:
is_train = self.for_training
if is_train:
self._labels = data_batch.label[0] | python | def forward(self, data_batch, is_train=None):
"""Forward computation. Here we do nothing but to keep a reference to
the scores and the labels so that we can do backward computation.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means `is_train` takes the value of ``self.for_training``.
"""
self._scores = data_batch.data[0]
if is_train is None:
is_train = self.for_training
if is_train:
self._labels = data_batch.label[0] | [
"def",
"forward",
"(",
"self",
",",
"data_batch",
",",
"is_train",
"=",
"None",
")",
":",
"self",
".",
"_scores",
"=",
"data_batch",
".",
"data",
"[",
"0",
"]",
"if",
"is_train",
"is",
"None",
":",
"is_train",
"=",
"self",
".",
"for_training",
"if",
"is_train",
":",
"self",
".",
"_labels",
"=",
"data_batch",
".",
"label",
"[",
"0",
"]"
] | Forward computation. Here we do nothing but to keep a reference to
the scores and the labels so that we can do backward computation.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means `is_train` takes the value of ``self.for_training``. | [
"Forward",
"computation",
".",
"Here",
"we",
"do",
"nothing",
"but",
"to",
"keep",
"a",
"reference",
"to",
"the",
"scores",
"and",
"the",
"labels",
"so",
"that",
"we",
"can",
"do",
"backward",
"computation",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/python_module.py#L285-L302 |
23,690 | apache/incubator-mxnet | python/mxnet/module/python_module.py | PythonLossModule._backward_impl | def _backward_impl(self):
"""Actual implementation of the backward computation. The computation
should take ``self._scores`` and ``self._labels`` and then compute the
gradients with respect to the scores, store it as an `NDArray` in
``self._scores_grad``.
Instead of defining a subclass and overriding this function,
a more convenient way is to pass in a `grad_func` when constructing
the module object. Then it will be called to compute the gradients.
"""
if self._grad_func is not None:
grad = self._grad_func(self._scores, self._labels)
if not isinstance(grad, nd.NDArray):
grad = nd.array(grad)
self._scores_grad = grad
else:
raise NotImplementedError() | python | def _backward_impl(self):
"""Actual implementation of the backward computation. The computation
should take ``self._scores`` and ``self._labels`` and then compute the
gradients with respect to the scores, store it as an `NDArray` in
``self._scores_grad``.
Instead of defining a subclass and overriding this function,
a more convenient way is to pass in a `grad_func` when constructing
the module object. Then it will be called to compute the gradients.
"""
if self._grad_func is not None:
grad = self._grad_func(self._scores, self._labels)
if not isinstance(grad, nd.NDArray):
grad = nd.array(grad)
self._scores_grad = grad
else:
raise NotImplementedError() | [
"def",
"_backward_impl",
"(",
"self",
")",
":",
"if",
"self",
".",
"_grad_func",
"is",
"not",
"None",
":",
"grad",
"=",
"self",
".",
"_grad_func",
"(",
"self",
".",
"_scores",
",",
"self",
".",
"_labels",
")",
"if",
"not",
"isinstance",
"(",
"grad",
",",
"nd",
".",
"NDArray",
")",
":",
"grad",
"=",
"nd",
".",
"array",
"(",
"grad",
")",
"self",
".",
"_scores_grad",
"=",
"grad",
"else",
":",
"raise",
"NotImplementedError",
"(",
")"
] | Actual implementation of the backward computation. The computation
should take ``self._scores`` and ``self._labels`` and then compute the
gradients with respect to the scores, store it as an `NDArray` in
``self._scores_grad``.
Instead of defining a subclass and overriding this function,
a more convenient way is to pass in a `grad_func` when constructing
the module object. Then it will be called to compute the gradients. | [
"Actual",
"implementation",
"of",
"the",
"backward",
"computation",
".",
"The",
"computation",
"should",
"take",
"self",
".",
"_scores",
"and",
"self",
".",
"_labels",
"and",
"then",
"compute",
"the",
"gradients",
"with",
"respect",
"to",
"the",
"scores",
"store",
"it",
"as",
"an",
"NDArray",
"in",
"self",
".",
"_scores_grad",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/python_module.py#L331-L347 |
23,691 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | RNNParams.get | def get(self, name, **kwargs):
"""Get the variable given a name if one exists or create a new one if missing.
Parameters
----------
name : str
name of the variable
**kwargs :
more arguments that's passed to symbol.Variable
"""
name = self._prefix + name
if name not in self._params:
self._params[name] = symbol.Variable(name, **kwargs)
return self._params[name] | python | def get(self, name, **kwargs):
"""Get the variable given a name if one exists or create a new one if missing.
Parameters
----------
name : str
name of the variable
**kwargs :
more arguments that's passed to symbol.Variable
"""
name = self._prefix + name
if name not in self._params:
self._params[name] = symbol.Variable(name, **kwargs)
return self._params[name] | [
"def",
"get",
"(",
"self",
",",
"name",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
"=",
"self",
".",
"_prefix",
"+",
"name",
"if",
"name",
"not",
"in",
"self",
".",
"_params",
":",
"self",
".",
"_params",
"[",
"name",
"]",
"=",
"symbol",
".",
"Variable",
"(",
"name",
",",
"*",
"*",
"kwargs",
")",
"return",
"self",
".",
"_params",
"[",
"name",
"]"
] | Get the variable given a name if one exists or create a new one if missing.
Parameters
----------
name : str
name of the variable
**kwargs :
more arguments that's passed to symbol.Variable | [
"Get",
"the",
"variable",
"given",
"a",
"name",
"if",
"one",
"exists",
"or",
"create",
"a",
"new",
"one",
"if",
"missing",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L92-L105 |
23,692 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | BaseRNNCell.unpack_weights | def unpack_weights(self, args):
"""Unpack fused weight matrices into separate
weight matrices.
For example, say you use a module object `mod` to run a network that has an lstm cell.
In `mod.get_params()[0]`, the lstm parameters are all represented as a single big vector.
`cell.unpack_weights(mod.get_params()[0])` will unpack this vector into a dictionary of
more readable lstm parameters - c, f, i, o gates for i2h (input to hidden) and
h2h (hidden to hidden) weights.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing packed weights.
usually from `Module.get_params()[0]`.
Returns
-------
args : dict of str -> NDArray
Dictionary with unpacked weights associated with
this cell.
See Also
--------
pack_weights: Performs the reverse operation of this function.
"""
args = args.copy()
if not self._gate_names:
return args
h = self._num_hidden
for group_name in ['i2h', 'h2h']:
weight = args.pop('%s%s_weight'%(self._prefix, group_name))
bias = args.pop('%s%s_bias' % (self._prefix, group_name))
for j, gate in enumerate(self._gate_names):
wname = '%s%s%s_weight' % (self._prefix, group_name, gate)
args[wname] = weight[j*h:(j+1)*h].copy()
bname = '%s%s%s_bias' % (self._prefix, group_name, gate)
args[bname] = bias[j*h:(j+1)*h].copy()
return args | python | def unpack_weights(self, args):
"""Unpack fused weight matrices into separate
weight matrices.
For example, say you use a module object `mod` to run a network that has an lstm cell.
In `mod.get_params()[0]`, the lstm parameters are all represented as a single big vector.
`cell.unpack_weights(mod.get_params()[0])` will unpack this vector into a dictionary of
more readable lstm parameters - c, f, i, o gates for i2h (input to hidden) and
h2h (hidden to hidden) weights.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing packed weights.
usually from `Module.get_params()[0]`.
Returns
-------
args : dict of str -> NDArray
Dictionary with unpacked weights associated with
this cell.
See Also
--------
pack_weights: Performs the reverse operation of this function.
"""
args = args.copy()
if not self._gate_names:
return args
h = self._num_hidden
for group_name in ['i2h', 'h2h']:
weight = args.pop('%s%s_weight'%(self._prefix, group_name))
bias = args.pop('%s%s_bias' % (self._prefix, group_name))
for j, gate in enumerate(self._gate_names):
wname = '%s%s%s_weight' % (self._prefix, group_name, gate)
args[wname] = weight[j*h:(j+1)*h].copy()
bname = '%s%s%s_bias' % (self._prefix, group_name, gate)
args[bname] = bias[j*h:(j+1)*h].copy()
return args | [
"def",
"unpack_weights",
"(",
"self",
",",
"args",
")",
":",
"args",
"=",
"args",
".",
"copy",
"(",
")",
"if",
"not",
"self",
".",
"_gate_names",
":",
"return",
"args",
"h",
"=",
"self",
".",
"_num_hidden",
"for",
"group_name",
"in",
"[",
"'i2h'",
",",
"'h2h'",
"]",
":",
"weight",
"=",
"args",
".",
"pop",
"(",
"'%s%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
")",
")",
"bias",
"=",
"args",
".",
"pop",
"(",
"'%s%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
")",
")",
"for",
"j",
",",
"gate",
"in",
"enumerate",
"(",
"self",
".",
"_gate_names",
")",
":",
"wname",
"=",
"'%s%s%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
",",
"gate",
")",
"args",
"[",
"wname",
"]",
"=",
"weight",
"[",
"j",
"*",
"h",
":",
"(",
"j",
"+",
"1",
")",
"*",
"h",
"]",
".",
"copy",
"(",
")",
"bname",
"=",
"'%s%s%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
",",
"gate",
")",
"args",
"[",
"bname",
"]",
"=",
"bias",
"[",
"j",
"*",
"h",
":",
"(",
"j",
"+",
"1",
")",
"*",
"h",
"]",
".",
"copy",
"(",
")",
"return",
"args"
] | Unpack fused weight matrices into separate
weight matrices.
For example, say you use a module object `mod` to run a network that has an lstm cell.
In `mod.get_params()[0]`, the lstm parameters are all represented as a single big vector.
`cell.unpack_weights(mod.get_params()[0])` will unpack this vector into a dictionary of
more readable lstm parameters - c, f, i, o gates for i2h (input to hidden) and
h2h (hidden to hidden) weights.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing packed weights.
usually from `Module.get_params()[0]`.
Returns
-------
args : dict of str -> NDArray
Dictionary with unpacked weights associated with
this cell.
See Also
--------
pack_weights: Performs the reverse operation of this function. | [
"Unpack",
"fused",
"weight",
"matrices",
"into",
"separate",
"weight",
"matrices",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L225-L263 |
23,693 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | BaseRNNCell.pack_weights | def pack_weights(self, args):
"""Pack separate weight matrices into a single packed
weight.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing unpacked weights.
Returns
-------
args : dict of str -> NDArray
Dictionary with packed weights associated with
this cell.
"""
args = args.copy()
if not self._gate_names:
return args
for group_name in ['i2h', 'h2h']:
weight = []
bias = []
for gate in self._gate_names:
wname = '%s%s%s_weight'%(self._prefix, group_name, gate)
weight.append(args.pop(wname))
bname = '%s%s%s_bias'%(self._prefix, group_name, gate)
bias.append(args.pop(bname))
args['%s%s_weight'%(self._prefix, group_name)] = ndarray.concatenate(weight)
args['%s%s_bias'%(self._prefix, group_name)] = ndarray.concatenate(bias)
return args | python | def pack_weights(self, args):
"""Pack separate weight matrices into a single packed
weight.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing unpacked weights.
Returns
-------
args : dict of str -> NDArray
Dictionary with packed weights associated with
this cell.
"""
args = args.copy()
if not self._gate_names:
return args
for group_name in ['i2h', 'h2h']:
weight = []
bias = []
for gate in self._gate_names:
wname = '%s%s%s_weight'%(self._prefix, group_name, gate)
weight.append(args.pop(wname))
bname = '%s%s%s_bias'%(self._prefix, group_name, gate)
bias.append(args.pop(bname))
args['%s%s_weight'%(self._prefix, group_name)] = ndarray.concatenate(weight)
args['%s%s_bias'%(self._prefix, group_name)] = ndarray.concatenate(bias)
return args | [
"def",
"pack_weights",
"(",
"self",
",",
"args",
")",
":",
"args",
"=",
"args",
".",
"copy",
"(",
")",
"if",
"not",
"self",
".",
"_gate_names",
":",
"return",
"args",
"for",
"group_name",
"in",
"[",
"'i2h'",
",",
"'h2h'",
"]",
":",
"weight",
"=",
"[",
"]",
"bias",
"=",
"[",
"]",
"for",
"gate",
"in",
"self",
".",
"_gate_names",
":",
"wname",
"=",
"'%s%s%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
",",
"gate",
")",
"weight",
".",
"append",
"(",
"args",
".",
"pop",
"(",
"wname",
")",
")",
"bname",
"=",
"'%s%s%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
",",
"gate",
")",
"bias",
".",
"append",
"(",
"args",
".",
"pop",
"(",
"bname",
")",
")",
"args",
"[",
"'%s%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
")",
"]",
"=",
"ndarray",
".",
"concatenate",
"(",
"weight",
")",
"args",
"[",
"'%s%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"group_name",
")",
"]",
"=",
"ndarray",
".",
"concatenate",
"(",
"bias",
")",
"return",
"args"
] | Pack separate weight matrices into a single packed
weight.
Parameters
----------
args : dict of str -> NDArray
Dictionary containing unpacked weights.
Returns
-------
args : dict of str -> NDArray
Dictionary with packed weights associated with
this cell. | [
"Pack",
"separate",
"weight",
"matrices",
"into",
"a",
"single",
"packed",
"weight",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L265-L293 |
23,694 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | BaseRNNCell.unroll | def unroll(self, length, inputs, begin_state=None, layout='NTC', merge_outputs=None):
"""Unroll an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, default None
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if None.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If False, return outputs as a list of Symbols.
If True, concatenate output across time steps
and return a single symbol with shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If None, output whatever is faster.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : nested list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of begin_state().
"""
self.reset()
inputs, _ = _normalize_sequence(length, inputs, layout, False)
if begin_state is None:
begin_state = self.begin_state()
states = begin_state
outputs = []
for i in range(length):
output, states = self(inputs[i], states)
outputs.append(output)
outputs, _ = _normalize_sequence(length, outputs, layout, merge_outputs)
return outputs, states | python | def unroll(self, length, inputs, begin_state=None, layout='NTC', merge_outputs=None):
"""Unroll an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, default None
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if None.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If False, return outputs as a list of Symbols.
If True, concatenate output across time steps
and return a single symbol with shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If None, output whatever is faster.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : nested list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of begin_state().
"""
self.reset()
inputs, _ = _normalize_sequence(length, inputs, layout, False)
if begin_state is None:
begin_state = self.begin_state()
states = begin_state
outputs = []
for i in range(length):
output, states = self(inputs[i], states)
outputs.append(output)
outputs, _ = _normalize_sequence(length, outputs, layout, merge_outputs)
return outputs, states | [
"def",
"unroll",
"(",
"self",
",",
"length",
",",
"inputs",
",",
"begin_state",
"=",
"None",
",",
"layout",
"=",
"'NTC'",
",",
"merge_outputs",
"=",
"None",
")",
":",
"self",
".",
"reset",
"(",
")",
"inputs",
",",
"_",
"=",
"_normalize_sequence",
"(",
"length",
",",
"inputs",
",",
"layout",
",",
"False",
")",
"if",
"begin_state",
"is",
"None",
":",
"begin_state",
"=",
"self",
".",
"begin_state",
"(",
")",
"states",
"=",
"begin_state",
"outputs",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"length",
")",
":",
"output",
",",
"states",
"=",
"self",
"(",
"inputs",
"[",
"i",
"]",
",",
"states",
")",
"outputs",
".",
"append",
"(",
"output",
")",
"outputs",
",",
"_",
"=",
"_normalize_sequence",
"(",
"length",
",",
"outputs",
",",
"layout",
",",
"merge_outputs",
")",
"return",
"outputs",
",",
"states"
] | Unroll an RNN cell across time steps.
Parameters
----------
length : int
Number of steps to unroll.
inputs : Symbol, list of Symbol, or None
If `inputs` is a single Symbol (usually the output
of Embedding symbol), it should have shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If `inputs` is a list of symbols (usually output of
previous unroll), they should all have shape
(batch_size, ...).
begin_state : nested list of Symbol, default None
Input states created by `begin_state()`
or output state of another cell.
Created from `begin_state()` if None.
layout : str, optional
`layout` of input symbol. Only used if inputs
is a single Symbol.
merge_outputs : bool, optional
If False, return outputs as a list of Symbols.
If True, concatenate output across time steps
and return a single symbol with shape
(batch_size, length, ...) if layout == 'NTC',
or (length, batch_size, ...) if layout == 'TNC'.
If None, output whatever is faster.
Returns
-------
outputs : list of Symbol or Symbol
Symbol (if `merge_outputs` is True) or list of Symbols
(if `merge_outputs` is False) corresponding to the output from
the RNN from this unrolling.
states : nested list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of begin_state(). | [
"Unroll",
"an",
"RNN",
"cell",
"across",
"time",
"steps",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L295-L351 |
23,695 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | FusedRNNCell._slice_weights | def _slice_weights(self, arr, li, lh):
"""slice fused rnn weights"""
args = {}
gate_names = self._gate_names
directions = self._directions
b = len(directions)
p = 0
for layer in range(self._num_layers):
for direction in directions:
for gate in gate_names:
name = '%s%s%d_i2h%s_weight'%(self._prefix, direction, layer, gate)
if layer > 0:
size = b*lh*lh
args[name] = arr[p:p+size].reshape((lh, b*lh))
else:
size = li*lh
args[name] = arr[p:p+size].reshape((lh, li))
p += size
for gate in gate_names:
name = '%s%s%d_h2h%s_weight'%(self._prefix, direction, layer, gate)
size = lh**2
args[name] = arr[p:p+size].reshape((lh, lh))
p += size
for layer in range(self._num_layers):
for direction in directions:
for gate in gate_names:
name = '%s%s%d_i2h%s_bias'%(self._prefix, direction, layer, gate)
args[name] = arr[p:p+lh]
p += lh
for gate in gate_names:
name = '%s%s%d_h2h%s_bias'%(self._prefix, direction, layer, gate)
args[name] = arr[p:p+lh]
p += lh
assert p == arr.size, "Invalid parameters size for FusedRNNCell"
return args | python | def _slice_weights(self, arr, li, lh):
"""slice fused rnn weights"""
args = {}
gate_names = self._gate_names
directions = self._directions
b = len(directions)
p = 0
for layer in range(self._num_layers):
for direction in directions:
for gate in gate_names:
name = '%s%s%d_i2h%s_weight'%(self._prefix, direction, layer, gate)
if layer > 0:
size = b*lh*lh
args[name] = arr[p:p+size].reshape((lh, b*lh))
else:
size = li*lh
args[name] = arr[p:p+size].reshape((lh, li))
p += size
for gate in gate_names:
name = '%s%s%d_h2h%s_weight'%(self._prefix, direction, layer, gate)
size = lh**2
args[name] = arr[p:p+size].reshape((lh, lh))
p += size
for layer in range(self._num_layers):
for direction in directions:
for gate in gate_names:
name = '%s%s%d_i2h%s_bias'%(self._prefix, direction, layer, gate)
args[name] = arr[p:p+lh]
p += lh
for gate in gate_names:
name = '%s%s%d_h2h%s_bias'%(self._prefix, direction, layer, gate)
args[name] = arr[p:p+lh]
p += lh
assert p == arr.size, "Invalid parameters size for FusedRNNCell"
return args | [
"def",
"_slice_weights",
"(",
"self",
",",
"arr",
",",
"li",
",",
"lh",
")",
":",
"args",
"=",
"{",
"}",
"gate_names",
"=",
"self",
".",
"_gate_names",
"directions",
"=",
"self",
".",
"_directions",
"b",
"=",
"len",
"(",
"directions",
")",
"p",
"=",
"0",
"for",
"layer",
"in",
"range",
"(",
"self",
".",
"_num_layers",
")",
":",
"for",
"direction",
"in",
"directions",
":",
"for",
"gate",
"in",
"gate_names",
":",
"name",
"=",
"'%s%s%d_i2h%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"direction",
",",
"layer",
",",
"gate",
")",
"if",
"layer",
">",
"0",
":",
"size",
"=",
"b",
"*",
"lh",
"*",
"lh",
"args",
"[",
"name",
"]",
"=",
"arr",
"[",
"p",
":",
"p",
"+",
"size",
"]",
".",
"reshape",
"(",
"(",
"lh",
",",
"b",
"*",
"lh",
")",
")",
"else",
":",
"size",
"=",
"li",
"*",
"lh",
"args",
"[",
"name",
"]",
"=",
"arr",
"[",
"p",
":",
"p",
"+",
"size",
"]",
".",
"reshape",
"(",
"(",
"lh",
",",
"li",
")",
")",
"p",
"+=",
"size",
"for",
"gate",
"in",
"gate_names",
":",
"name",
"=",
"'%s%s%d_h2h%s_weight'",
"%",
"(",
"self",
".",
"_prefix",
",",
"direction",
",",
"layer",
",",
"gate",
")",
"size",
"=",
"lh",
"**",
"2",
"args",
"[",
"name",
"]",
"=",
"arr",
"[",
"p",
":",
"p",
"+",
"size",
"]",
".",
"reshape",
"(",
"(",
"lh",
",",
"lh",
")",
")",
"p",
"+=",
"size",
"for",
"layer",
"in",
"range",
"(",
"self",
".",
"_num_layers",
")",
":",
"for",
"direction",
"in",
"directions",
":",
"for",
"gate",
"in",
"gate_names",
":",
"name",
"=",
"'%s%s%d_i2h%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"direction",
",",
"layer",
",",
"gate",
")",
"args",
"[",
"name",
"]",
"=",
"arr",
"[",
"p",
":",
"p",
"+",
"lh",
"]",
"p",
"+=",
"lh",
"for",
"gate",
"in",
"gate_names",
":",
"name",
"=",
"'%s%s%d_h2h%s_bias'",
"%",
"(",
"self",
".",
"_prefix",
",",
"direction",
",",
"layer",
",",
"gate",
")",
"args",
"[",
"name",
"]",
"=",
"arr",
"[",
"p",
":",
"p",
"+",
"lh",
"]",
"p",
"+=",
"lh",
"assert",
"p",
"==",
"arr",
".",
"size",
",",
"\"Invalid parameters size for FusedRNNCell\"",
"return",
"args"
] | slice fused rnn weights | [
"slice",
"fused",
"rnn",
"weights"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L600-L637 |
23,696 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | FusedRNNCell.unfuse | def unfuse(self):
"""Unfuse the fused RNN in to a stack of rnn cells.
Returns
-------
cell : mxnet.rnn.SequentialRNNCell
unfused cell that can be used for stepping, and can run on CPU.
"""
stack = SequentialRNNCell()
get_cell = {'rnn_relu': lambda cell_prefix: RNNCell(self._num_hidden,
activation='relu',
prefix=cell_prefix),
'rnn_tanh': lambda cell_prefix: RNNCell(self._num_hidden,
activation='tanh',
prefix=cell_prefix),
'lstm': lambda cell_prefix: LSTMCell(self._num_hidden,
prefix=cell_prefix),
'gru': lambda cell_prefix: GRUCell(self._num_hidden,
prefix=cell_prefix)}[self._mode]
for i in range(self._num_layers):
if self._bidirectional:
stack.add(BidirectionalCell(
get_cell('%sl%d_'%(self._prefix, i)),
get_cell('%sr%d_'%(self._prefix, i)),
output_prefix='%sbi_l%d_'%(self._prefix, i)))
else:
stack.add(get_cell('%sl%d_'%(self._prefix, i)))
if self._dropout > 0 and i != self._num_layers - 1:
stack.add(DropoutCell(self._dropout, prefix='%s_dropout%d_'%(self._prefix, i)))
return stack | python | def unfuse(self):
"""Unfuse the fused RNN in to a stack of rnn cells.
Returns
-------
cell : mxnet.rnn.SequentialRNNCell
unfused cell that can be used for stepping, and can run on CPU.
"""
stack = SequentialRNNCell()
get_cell = {'rnn_relu': lambda cell_prefix: RNNCell(self._num_hidden,
activation='relu',
prefix=cell_prefix),
'rnn_tanh': lambda cell_prefix: RNNCell(self._num_hidden,
activation='tanh',
prefix=cell_prefix),
'lstm': lambda cell_prefix: LSTMCell(self._num_hidden,
prefix=cell_prefix),
'gru': lambda cell_prefix: GRUCell(self._num_hidden,
prefix=cell_prefix)}[self._mode]
for i in range(self._num_layers):
if self._bidirectional:
stack.add(BidirectionalCell(
get_cell('%sl%d_'%(self._prefix, i)),
get_cell('%sr%d_'%(self._prefix, i)),
output_prefix='%sbi_l%d_'%(self._prefix, i)))
else:
stack.add(get_cell('%sl%d_'%(self._prefix, i)))
if self._dropout > 0 and i != self._num_layers - 1:
stack.add(DropoutCell(self._dropout, prefix='%s_dropout%d_'%(self._prefix, i)))
return stack | [
"def",
"unfuse",
"(",
"self",
")",
":",
"stack",
"=",
"SequentialRNNCell",
"(",
")",
"get_cell",
"=",
"{",
"'rnn_relu'",
":",
"lambda",
"cell_prefix",
":",
"RNNCell",
"(",
"self",
".",
"_num_hidden",
",",
"activation",
"=",
"'relu'",
",",
"prefix",
"=",
"cell_prefix",
")",
",",
"'rnn_tanh'",
":",
"lambda",
"cell_prefix",
":",
"RNNCell",
"(",
"self",
".",
"_num_hidden",
",",
"activation",
"=",
"'tanh'",
",",
"prefix",
"=",
"cell_prefix",
")",
",",
"'lstm'",
":",
"lambda",
"cell_prefix",
":",
"LSTMCell",
"(",
"self",
".",
"_num_hidden",
",",
"prefix",
"=",
"cell_prefix",
")",
",",
"'gru'",
":",
"lambda",
"cell_prefix",
":",
"GRUCell",
"(",
"self",
".",
"_num_hidden",
",",
"prefix",
"=",
"cell_prefix",
")",
"}",
"[",
"self",
".",
"_mode",
"]",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_num_layers",
")",
":",
"if",
"self",
".",
"_bidirectional",
":",
"stack",
".",
"add",
"(",
"BidirectionalCell",
"(",
"get_cell",
"(",
"'%sl%d_'",
"%",
"(",
"self",
".",
"_prefix",
",",
"i",
")",
")",
",",
"get_cell",
"(",
"'%sr%d_'",
"%",
"(",
"self",
".",
"_prefix",
",",
"i",
")",
")",
",",
"output_prefix",
"=",
"'%sbi_l%d_'",
"%",
"(",
"self",
".",
"_prefix",
",",
"i",
")",
")",
")",
"else",
":",
"stack",
".",
"add",
"(",
"get_cell",
"(",
"'%sl%d_'",
"%",
"(",
"self",
".",
"_prefix",
",",
"i",
")",
")",
")",
"if",
"self",
".",
"_dropout",
">",
"0",
"and",
"i",
"!=",
"self",
".",
"_num_layers",
"-",
"1",
":",
"stack",
".",
"add",
"(",
"DropoutCell",
"(",
"self",
".",
"_dropout",
",",
"prefix",
"=",
"'%s_dropout%d_'",
"%",
"(",
"self",
".",
"_prefix",
",",
"i",
")",
")",
")",
"return",
"stack"
] | Unfuse the fused RNN in to a stack of rnn cells.
Returns
-------
cell : mxnet.rnn.SequentialRNNCell
unfused cell that can be used for stepping, and can run on CPU. | [
"Unfuse",
"the",
"fused",
"RNN",
"in",
"to",
"a",
"stack",
"of",
"rnn",
"cells",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L714-L745 |
23,697 | apache/incubator-mxnet | python/mxnet/rnn/rnn_cell.py | SequentialRNNCell.add | def add(self, cell):
"""Append a cell into the stack.
Parameters
----------
cell : BaseRNNCell
The cell to be appended. During unroll, previous cell's output (or raw inputs if
no previous cell) is used as the input to this cell.
"""
self._cells.append(cell)
if self._override_cell_params:
assert cell._own_params, \
"Either specify params for SequentialRNNCell " \
"or child cells, not both."
cell.params._params.update(self.params._params)
self.params._params.update(cell.params._params) | python | def add(self, cell):
"""Append a cell into the stack.
Parameters
----------
cell : BaseRNNCell
The cell to be appended. During unroll, previous cell's output (or raw inputs if
no previous cell) is used as the input to this cell.
"""
self._cells.append(cell)
if self._override_cell_params:
assert cell._own_params, \
"Either specify params for SequentialRNNCell " \
"or child cells, not both."
cell.params._params.update(self.params._params)
self.params._params.update(cell.params._params) | [
"def",
"add",
"(",
"self",
",",
"cell",
")",
":",
"self",
".",
"_cells",
".",
"append",
"(",
"cell",
")",
"if",
"self",
".",
"_override_cell_params",
":",
"assert",
"cell",
".",
"_own_params",
",",
"\"Either specify params for SequentialRNNCell \"",
"\"or child cells, not both.\"",
"cell",
".",
"params",
".",
"_params",
".",
"update",
"(",
"self",
".",
"params",
".",
"_params",
")",
"self",
".",
"params",
".",
"_params",
".",
"update",
"(",
"cell",
".",
"params",
".",
"_params",
")"
] | Append a cell into the stack.
Parameters
----------
cell : BaseRNNCell
The cell to be appended. During unroll, previous cell's output (or raw inputs if
no previous cell) is used as the input to this cell. | [
"Append",
"a",
"cell",
"into",
"the",
"stack",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn_cell.py#L761-L776 |
23,698 | apache/incubator-mxnet | tools/caffe_converter/compare_layers.py | main | def main():
"""Entrypoint for compare_layers"""
parser = argparse.ArgumentParser(
description='Tool for testing caffe to mxnet conversion layer by layer')
parser.add_argument('--image_url', type=str,
default='https://github.com/dmlc/web-data/raw/master/mxnet/doc/'\
'tutorials/python/predict_image/cat.jpg',
help='input image to test inference, can be either file path or url')
parser.add_argument('--caffe_prototxt_path', type=str,
default='./model.prototxt',
help='path to caffe prototxt')
parser.add_argument('--caffe_model_path', type=str,
default='./model.caffemodel',
help='path to caffe weights')
parser.add_argument('--caffe_mean', type=str,
default='./model_mean.binaryproto',
help='path to caffe mean file')
parser.add_argument('--mean_diff_allowed', type=int, default=1e-03,
help='mean difference allowed between caffe blob and mxnet blob')
parser.add_argument('--max_diff_allowed', type=int, default=1e-01,
help='max difference allowed between caffe blob and mxnet blob')
parser.add_argument('--gpu', type=int, default=-1, help='the gpu id used for predict')
args = parser.parse_args()
convert_and_compare_caffe_to_mxnet(args.image_url, args.gpu, args.caffe_prototxt_path,
args.caffe_model_path, args.caffe_mean,
args.mean_diff_allowed, args.max_diff_allowed) | python | def main():
"""Entrypoint for compare_layers"""
parser = argparse.ArgumentParser(
description='Tool for testing caffe to mxnet conversion layer by layer')
parser.add_argument('--image_url', type=str,
default='https://github.com/dmlc/web-data/raw/master/mxnet/doc/'\
'tutorials/python/predict_image/cat.jpg',
help='input image to test inference, can be either file path or url')
parser.add_argument('--caffe_prototxt_path', type=str,
default='./model.prototxt',
help='path to caffe prototxt')
parser.add_argument('--caffe_model_path', type=str,
default='./model.caffemodel',
help='path to caffe weights')
parser.add_argument('--caffe_mean', type=str,
default='./model_mean.binaryproto',
help='path to caffe mean file')
parser.add_argument('--mean_diff_allowed', type=int, default=1e-03,
help='mean difference allowed between caffe blob and mxnet blob')
parser.add_argument('--max_diff_allowed', type=int, default=1e-01,
help='max difference allowed between caffe blob and mxnet blob')
parser.add_argument('--gpu', type=int, default=-1, help='the gpu id used for predict')
args = parser.parse_args()
convert_and_compare_caffe_to_mxnet(args.image_url, args.gpu, args.caffe_prototxt_path,
args.caffe_model_path, args.caffe_mean,
args.mean_diff_allowed, args.max_diff_allowed) | [
"def",
"main",
"(",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"description",
"=",
"'Tool for testing caffe to mxnet conversion layer by layer'",
")",
"parser",
".",
"add_argument",
"(",
"'--image_url'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'https://github.com/dmlc/web-data/raw/master/mxnet/doc/'",
"'tutorials/python/predict_image/cat.jpg'",
",",
"help",
"=",
"'input image to test inference, can be either file path or url'",
")",
"parser",
".",
"add_argument",
"(",
"'--caffe_prototxt_path'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'./model.prototxt'",
",",
"help",
"=",
"'path to caffe prototxt'",
")",
"parser",
".",
"add_argument",
"(",
"'--caffe_model_path'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'./model.caffemodel'",
",",
"help",
"=",
"'path to caffe weights'",
")",
"parser",
".",
"add_argument",
"(",
"'--caffe_mean'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'./model_mean.binaryproto'",
",",
"help",
"=",
"'path to caffe mean file'",
")",
"parser",
".",
"add_argument",
"(",
"'--mean_diff_allowed'",
",",
"type",
"=",
"int",
",",
"default",
"=",
"1e-03",
",",
"help",
"=",
"'mean difference allowed between caffe blob and mxnet blob'",
")",
"parser",
".",
"add_argument",
"(",
"'--max_diff_allowed'",
",",
"type",
"=",
"int",
",",
"default",
"=",
"1e-01",
",",
"help",
"=",
"'max difference allowed between caffe blob and mxnet blob'",
")",
"parser",
".",
"add_argument",
"(",
"'--gpu'",
",",
"type",
"=",
"int",
",",
"default",
"=",
"-",
"1",
",",
"help",
"=",
"'the gpu id used for predict'",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"convert_and_compare_caffe_to_mxnet",
"(",
"args",
".",
"image_url",
",",
"args",
".",
"gpu",
",",
"args",
".",
"caffe_prototxt_path",
",",
"args",
".",
"caffe_model_path",
",",
"args",
".",
"caffe_mean",
",",
"args",
".",
"mean_diff_allowed",
",",
"args",
".",
"max_diff_allowed",
")"
] | Entrypoint for compare_layers | [
"Entrypoint",
"for",
"compare_layers"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/tools/caffe_converter/compare_layers.py#L338-L364 |
23,699 | apache/incubator-mxnet | example/bayesian-methods/utils.py | copy_param | def copy_param(exe, new_param=None):
"""Create copy of parameters"""
if new_param is None:
new_param = {k: nd.empty(v.shape, ctx=mx.cpu()) for k, v in exe.arg_dict.items()}
for k, v in new_param.items():
exe.arg_dict[k].copyto(v)
return new_param | python | def copy_param(exe, new_param=None):
"""Create copy of parameters"""
if new_param is None:
new_param = {k: nd.empty(v.shape, ctx=mx.cpu()) for k, v in exe.arg_dict.items()}
for k, v in new_param.items():
exe.arg_dict[k].copyto(v)
return new_param | [
"def",
"copy_param",
"(",
"exe",
",",
"new_param",
"=",
"None",
")",
":",
"if",
"new_param",
"is",
"None",
":",
"new_param",
"=",
"{",
"k",
":",
"nd",
".",
"empty",
"(",
"v",
".",
"shape",
",",
"ctx",
"=",
"mx",
".",
"cpu",
"(",
")",
")",
"for",
"k",
",",
"v",
"in",
"exe",
".",
"arg_dict",
".",
"items",
"(",
")",
"}",
"for",
"k",
",",
"v",
"in",
"new_param",
".",
"items",
"(",
")",
":",
"exe",
".",
"arg_dict",
"[",
"k",
"]",
".",
"copyto",
"(",
"v",
")",
"return",
"new_param"
] | Create copy of parameters | [
"Create",
"copy",
"of",
"parameters"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/bayesian-methods/utils.py#L69-L75 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.