def __init__(self,
input_layer,
hidden_size=1,
identity_scale=1.,
input_weight_std=1e-3,
reverse_seq=False,
name=None):
if type(input_layer) is PythonWrapper.Irnn:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
if hidden_size <= 0:
raise ValueError('The `hidden_size` must be > 0.')
if identity_scale < 0:
raise ValueError('The `identity_scale` must be > 0.')
if input_weight_std < 0:
raise ValueError('The `input_weight_std` must be > 0.')
internal = PythonWrapper.Irnn(str(name), layers, outputs,
int(hidden_size), float(identity_scale),
float(input_weight_std),
bool(reverse_seq))
super().__init__(internal)
def __init__(self,
input_layer,
head_count,
hidden_size,
output_size,
dropout_rate,
name=None):
if type(input_layer) is PythonWrapper.MultiheadAttention:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, (3, 4))
if head_count < 1:
raise ValueError('The `head_count` must be > 0.')
if hidden_size < 1:
raise ValueError('The `hidden_size` must be > 0.')
if output_size < 1:
raise ValueError('The `output_size` must be > 0.')
internal = PythonWrapper.MultiheadAttention(str(name), layers, outputs,
int(head_count),
int(hidden_size),
int(output_size),
dropout_rate)
super().__init__(internal)
def __init__(self,
input_layer,
class_count,
padding=0,
dropout_rate=0.0,
name=None):
if type(input_layer) is PythonWrapper.Crf:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, (1, 2))
if class_count < 1:
raise ValueError('The `class_count` must be > 0.')
if padding < 0:
raise ValueError('The `padding` must be >= 0.')
if float(dropout_rate) < 0 or float(dropout_rate) >= 1:
raise ValueError('The `dropout_rate` must be in [0, 1).')
internal = PythonWrapper.Crf(str(name), layers, outputs, class_count,
padding, dropout_rate)
super().__init__(internal)
def __init__(self, input_layer, transforms, name=None):
if type(input_layer) is PythonWrapper.Transform:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
if len(transforms) != 7:
raise ValueError('The `transforms` array must have 7 elements.')
operations = numpy.ones(7, numpy.int32)
parameters = numpy.ones(7, numpy.int32)
for i in range(len(transforms)):
if len(transforms[i]) != 2:
raise ValueError(
'The `transforms` array must contain pairs (operation, value).'
)
operations[i] = self.rules.index(transforms[i][0])
if transforms[i][1] < 0:
raise ValueError('All values in `transforms` must be >= 0.')
parameters[i] = transforms[i][1]
internal = PythonWrapper.Transform(str(name), layers[0],
int(outputs[0]), operations,
parameters)
super().__init__(internal)
def __init__(self,
input_layer,
hidden_size=1,
dropout_rate=0.,
reverse_sequence=False,
activation='relu',
name=None):
if type(input_layer) is PythonWrapper.IndRnn:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
if hidden_size <= 0:
raise ValueError('The `hidden_size` must be > 0.')
if dropout_rate >= 1.:
raise ValueError('The `dropout_rate` must be < 1.')
if activation != 'sigmoid' and activation != 'relu':
raise ValueError(
'The `activation` must be one of {`sigmoid`, `relu`}')
internal = PythonWrapper.IndRnn(str(name), layers, outputs,
int(hidden_size), float(dropout_rate),
bool(reverse_sequence),
str(activation))
super().__init__(internal)
def __init__(self,
input_layer,
hidden_size=1,
dropout_rate=0.0,
activation="sigmoid",
reverse_seq=False,
name=None):
if type(input_layer) is PythonWrapper.Lstm:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, (1, 3))
if hidden_size <= 0:
raise ValueError('The `hidden_size` must be > 0.')
if dropout_rate < 0 or dropout_rate >= 1:
raise ValueError('The `dropout_rate` must be in [0, 1).')
recurrent_activation_index = self.activations.index(activation)
internal = PythonWrapper.Lstm(str(name), layers, outputs,
int(hidden_size), float(dropout_rate),
recurrent_activation_index,
bool(reverse_seq))
super().__init__(internal)
def __init__(self,
input_layers,
score,
hidden_size,
output_object_size,
output_seq_len,
name=None):
if type(input_layers) is PythonWrapper.AttentionDecoder:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 2)
score_index = self.scores.index(score)
if output_object_size <= 0:
raise ValueError('`output_object_size` must be > 0.')
if output_seq_len <= 0:
raise ValueError('`output_seq_len` must be > 0.')
if hidden_size <= 0:
raise ValueError('`hidden_size` must be > 0.')
internal = PythonWrapper.AttentionDecoder(str(name), layers[0],
int(outputs[0]), layers[1],
int(outputs[1]), score_index,
int(output_object_size),
int(output_seq_len),
int(hidden_size))
super().__init__(internal)
def __init__(self, input_layers, dimensions=None, name=None):
if dimensions is None:
dimensions = [(1, 1)]
if not type(dimensions) is list:
raise ValueError(
'`dimensions` must be a list of elements like (VectorCount, VectorSize).'
)
if any(not type(d) is tuple for d in dimensions):
raise ValueError(
'`dimensions` must be a list of elements like (VectorCount, VectorSize).'
)
if any(len(d) != 2 for d in dimensions):
raise ValueError(
'`dimensions` must be a list of elements like (VectorCount, VectorSize).'
)
if any(d[0] < 0 or d[1] < 1 for d in dimensions):
raise ValueError(
'`dimensions` must be a list of elements like (VectorCount, VectorSize).'
)
if type(input_layers) is PythonWrapper.MultichannelLookup:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 0)
internal = PythonWrapper.MultichannelLookup(str(name), layers, outputs,
dimensions)
super().__init__(internal)
def __init__(self, input_layers, head_count=1, hidden_size=1, dropout=0., feed_forward_size=1, activation='relu', name=None):
if type(input_layers) is PythonWrapper.TransformerEncoder:
super().__init__(input_layers)
return
if head_count < 1:
raise ValueError('The `head_count` must be > 0.')
if hidden_size < 1:
raise ValueError('The `hidden_size` must be > 0.')
if hidden_size % head_count != 0:
raise ValueError('The `hidden_size` must be a multiple of `head_count`')
if dropout >= 1.:
raise ValueError('The `dropout` must be < 1.')
if feed_forward_size < 1:
raise ValueError('The `feed_forward_size` must be > 0.')
if activation not in self.activations:
raise ValueError('The `activation` has invalid value')
activation = self.activations.index(activation)
layers, outputs = check_input_layers(input_layers, (1, 2))
internal = PythonWrapper.TransformerEncoder(str(name), layers, outputs,
int(head_count), int(hidden_size), float(dropout), int(feed_forward_size), int(activation))
super().__init__(internal)
def __init__(self, input_layer, name=None):
if type(input_layer) is PythonWrapper.BertConv:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 2)
internal = PythonWrapper.BertConv(str(name), layers, outputs)
super().__init__(internal)
def __init__(self,
input_layers,
pooling_type='f',
hidden_size=1,
window_size=1,
stride=1,
paddings=(0, 0),
activation="tanh",
dropout=0.0,
mode="direct",
name=None):
if type(input_layers) is PythonWrapper.Qrnn:
super().__init__(input_layers)
return
pooling_type_index = self.pooling_types.index(pooling_type)
if hidden_size < 1:
raise ValueError('The `hidden_size` must be > 0.')
if window_size < 1:
raise ValueError('The `window_size` must be > 0.')
if stride < 1:
raise ValueError('The `stride` must be > 0.')
if len(paddings) != 2:
raise ValueError(
'The `paddings` must have two values (padding_front, padding_back).'
)
padding_front = paddings[0]
if padding_front < 0:
raise ValueError('The `padding_front` must be >= 0.')
padding_back = paddings[1]
if padding_back < 0:
raise ValueError('The `padding_back` must be >= 0.')
activation_index = self.activations.index(activation)
if dropout < 0 or dropout >= 1:
raise ValueError('The `dropout` must be in [0, 1).')
mode_index = self.recurrent_modes.index(mode)
layers, outputs = check_input_layers(input_layers, (1, 2))
internal = PythonWrapper.Qrnn(str(name),
layers, int(pooling_type_index),
int(hidden_size), int(window_size),
int(stride), int(padding_front),
int(padding_back), activation_index,
float(dropout), mode_index, outputs)
super().__init__(internal)
def __init__(self, input_layers, name=None):
if type(input_layers) is PythonWrapper.MatrixMultiplication:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 2)
internal = PythonWrapper.MatrixMultiplication(str(name), layers[0], layers[1], int(outputs[0]), int(outputs[1]))
super().__init__(internal)
def __init__(self, input_layer, alpha, name=None):
if type(input_layer) is PythonWrapper.LeakyReLU:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.LeakyReLU(str(name), layers[0], int(outputs[0]), float(alpha))
super().__init__(internal)
def __init__(self, input_layers, name=None):
if type(input_layers) is PythonWrapper.GlobalMeanPooling:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 1)
internal = PythonWrapper.GlobalMeanPooling(str(name), layers[0], outputs[0])
super().__init__(internal)
def __init__(self, input_layer, multiplier, free_term, name=None):
if type(input_layer) is PythonWrapper.LinearLayer:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.LinearLayer(str(name), layers[0], int(outputs[0]), float(multiplier), float(free_term))
super().__init__(internal)
def __init__(self, input_layers, softmax=True, loss_weight=1.0, name=None):
if type(input_layers) is PythonWrapper.CrossEntropyLoss:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, (2, 3))
internal = PythonWrapper.CrossEntropyLoss(str(name), layers, outputs, bool(softmax), float(loss_weight))
super().__init__(internal)
def __init__(self, input_layer, exponent, name=None):
if type(input_layer) is PythonWrapper.Power:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.Power(str(name), layers[0], int(outputs[0]), float(exponent))
super().__init__(internal)
def __init__(self, input_layer, name=None):
if type(input_layer) is PythonWrapper.Sink:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.Sink(str(name), layers[0], int(outputs[0]))
super().__init__(internal)
def __init__(self, input_layers, class_count, rate, loss_weight=1.0, name=None):
if type(input_layers) is PythonWrapper.CenterLoss:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, (2, 3))
internal = PythonWrapper.CenterLoss(str(name), layers, outputs, int(class_count), float(rate), float(loss_weight))
super().__init__(internal)
def __init__(self, input_layer, slope, bias, name=None):
if type(input_layer) is PythonWrapper.HardSigmoid:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.HardSigmoid(str(name), layers[0], int(outputs[0]), float(slope), float(bias))
super().__init__(internal)
def __init__(self, input_layers, positive_weight=1.0, loss_weight=1.0, name=None):
if type(input_layers) is PythonWrapper.BinaryCrossEntropyLoss:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, (2, 3))
internal = PythonWrapper.BinaryCrossEntropyLoss(str(name), layers, outputs, float(positive_weight), float(loss_weight))
super().__init__(internal)
def __init__(self, input_layers, reset=True, name=None):
if type(input_layers) is PythonWrapper.Accuracy:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 2)
internal = PythonWrapper.Accuracy(str(name), layers[0], layers[1], int(outputs[0]), int(outputs[1]), bool(reset))
super().__init__(internal)
def __init__(self, input_layers, loss_weight=1.0, name=None):
if type(input_layers) is PythonWrapper.MultiSquaredHingeLoss:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, (2, 3))
internal = PythonWrapper.MultiSquaredHingeLoss(str(name), layers, outputs, float(loss_weight))
super().__init__(internal)
def __init__(self, input_layers, name=None):
if type(input_layers) is PythonWrapper.EltwiseMul:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 0)
internal = PythonWrapper.EltwiseMul(str(name), layers, outputs)
super().__init__(internal)
def __init__(self, input_layer, threshold=0.0, name=None):
if type(input_layer) is PythonWrapper.ReLU:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.ReLU(str(name), layers[0], int(outputs[0]), float(threshold))
super().__init__(internal)
def __init__(self, input_layers, name=None):
if type(input_layers) is PythonWrapper.BestSequence:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 2)
internal = PythonWrapper.BestSequence(str(name), layers, outputs)
super().__init__(internal)
def __init__(self, input_layers, name=None):
if type(input_layers) is PythonWrapper.AddToObject:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, 2)
internal = PythonWrapper.AddToObject(str(name), layers[0], layers[1],
int(outputs[0]), int(outputs[1]))
super().__init__(internal)
def __init__(self, input_layer, enum_size, name=None):
if type(input_layer) is PythonWrapper.EnumBinarization:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 1)
internal = PythonWrapper.EnumBinarization(str(name), layers[0],
int(outputs[0]), enum_size)
super().__init__(internal)
def __init__(self, input_layer, name=None):
if type(input_layer) is PythonWrapper.ImageToPixel:
super().__init__(input_layer)
return
layers, outputs = check_input_layers(input_layer, 2)
internal = PythonWrapper.ImageToPixel(str(name), layers[0], layers[1],
int(outputs[0]), int(outputs[1]))
super().__init__(internal)
def __init__(self, input_layers, blank, skip, loss_weight=1.0, name=None):
if type(input_layers) is PythonWrapper.CtcLoss:
super().__init__(input_layers)
return
layers, outputs = check_input_layers(input_layers, (2, 5))
internal = PythonWrapper.CtcLoss(str(name), layers, outputs,
int(blank), bool(skip),
float(loss_weight))
super().__init__(internal)
