def input_types(self):
"""Returns definitions of module input ports.
logit_intent_status: Output of SGD model
intent_status: intent label
logit_req_slot_status: Output of SGD model
requested_slot_status: Takes value 1 if the corresponding slot is requested, 0 otherwise
logit_cat_slot_status: Output of SGD model
categorical_slot_status: The status of each categorical slot in the service
logit_cat_slot_value_status: Output of SGD model
categorical_slot_value_status: Takes value 1 if the corresponding slot value is correct, 0 otherwise
logit_noncat_slot_status: Output of SGD model
noncategorical_slot_status: The status of each noncategorical slot in the service\
logit_spans: Output of SGD model
noncategorical_slot_value_start: The index of the starting subword corresponding to the slot span for a non-categorical slot value
noncategorical_slot_value_end: The index of the ending (inclusive) subword corresponding to the slot span for a non-categorical slot value
task_mask: Mask contains 1 if its the current task, 0 otherwise
"""
return {
"logit_intent_status": NeuralType(('B', 'T'), LogitsType()),
"intent_status": NeuralType(('B'), LabelsType()),
"logit_req_slot_status": NeuralType(('B', 'T'), LogitsType()),
"requested_slot_status": NeuralType(('B'), LabelsType()),
"logit_cat_slot_status": NeuralType(('B', 'T'), LogitsType()),
"categorical_slot_status": NeuralType(('B'), LabelsType()),
"logit_cat_slot_value_status": NeuralType(('B', 'T'), LogitsType()),
"categorical_slot_value_status": NeuralType(('B'), LabelsType()),
"logit_noncat_slot_status": NeuralType(('B', 'T'), LogitsType()),
"noncategorical_slot_status": NeuralType(('B'), LabelsType()),
"logit_spans": NeuralType(('B', 'T', 'D'), LogitsType()),
"noncategorical_slot_value_start": NeuralType(('B'), LabelsType()),
"noncategorical_slot_value_end": NeuralType(('B'), LabelsType()),
"task_mask": NeuralType(('B', 'T'), ChannelType()),
}
def output_ports(self):
return {
"mod_out":
NeuralType(
(AxisType(AxisKind.Batch), AxisType(AxisKind.Dimension, 1)),
ChannelType())
}
def output_ports(self):
"""Returns definitions of module output ports.
Returns:
A (dict) of module's output ports names to NeuralTypes mapping
"""
return {"y_pred": NeuralType(('B', 'D'), ChannelType())}
def output_ports(self):
"""Returns definitions of module output ports.
src_ids: ids of input sequences
src_lens: lengths of input sequences
tgt_ids: labels for the generator output
tgt_lens: lengths of the generator targets
gating_labels: labels for the gating head
turn_domain: list of the domains
NeuralType(None)
"""
return {
# "src_ids": NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag)}),
# "src_lens": NeuralType({0: AxisType(BatchTag)}),
# "tgt_ids": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(TimeTag)}),
# "tgt_lens": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag)}),
# "gating_labels": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag)}),
# "turn_domain": NeuralType(None),
"src_ids": NeuralType(('B', 'T'), ChannelType()),
"src_lens": NeuralType(tuple('B'), LengthsType()),
"tgt_ids": NeuralType(('B', 'D', 'T'), LabelsType()),
"tgt_lens": NeuralType(('B', 'D'), LengthsType()),
"gating_labels": NeuralType(('B', 'D'), LabelsType()),
"turn_domain": NeuralType(),
}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
"""Returns definitions of module output ports.
"""
return {
'input_ids':
NeuralType(('B', 'T'), ChannelType()),
'segment_ids':
NeuralType(('B', 'T'), ChannelType()),
'input_mask':
NeuralType(('B', 'T'), MaskType()),
"labels":
NeuralType(
tuple('B'),
RegressionValuesType()
if self.task_name == 'sts-b' else CategoricalValuesType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
# "interpolated_image": NeuralType(
# {
# 0: AxisType(BatchTag),
# 1: AxisType(ChannelTag),
# 2: AxisType(HeightTag, 28),
# 3: AxisType(WidthTag, 28),
# }
# ),
# "interpolated_decision": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag, 1)}),
"interpolated_image": NeuralType(('B', 'C', 'H', 'W'),
ChannelType()),
"interpolated_decision": NeuralType(('B', 'C'), ChannelType()),
}
def output_ports(self):
# return {"mod_out": NeuralType({0: AxisType(BatchTag), 1: AxisType(BaseTag, dim=1)})}
return {
"mod_out":
NeuralType(
(AxisType(AxisKind.Batch), AxisType(AxisKind.Dimension, 1)),
ChannelType())
}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
"""
Returns definitions of module output ports.
"""
return {
"logits": NeuralType(('B', 'T'), LogitsType()),
'hidden_states': NeuralType(('B', 'T', 'C'), ChannelType()),
}
def input_ports(self):
"""Return definitions of module input ports.
Returns:
Module input ports.
"""
return {
"encoding": NeuralType(('B', 'C', 'H', 'W'), ChannelType()),
}
def test_big_void(self):
big_void_1 = NeuralType(elements_type=VoidType())
big_void_2 = NeuralType()
btc_spctr = NeuralType(('B', 'T', 'C'), SpectrogramType())
btc_spct_bad = NeuralType(('B', 'T'), SpectrogramType())
t1 = NeuralType(
axes=(
AxisType(kind=AxisKind.Batch, size=None, is_list=True),
AxisType(kind=AxisKind.Time, size=None, is_list=True),
AxisType(kind=AxisKind.Dimension, size=32, is_list=False),
AxisType(kind=AxisKind.Dimension, size=128, is_list=False),
AxisType(kind=AxisKind.Dimension, size=256, is_list=False),
),
elements_type=ChannelType(),
)
t2 = NeuralType(
axes=(
AxisType(kind=AxisKind.Batch, size=None, is_list=False),
AxisType(kind=AxisKind.Time, size=None, is_list=False),
AxisType(kind=AxisKind.Dimension, size=32, is_list=False),
AxisType(kind=AxisKind.Dimension, size=128, is_list=False),
AxisType(kind=AxisKind.Dimension, size=256, is_list=False),
),
elements_type=ChannelType(),
)
self.assertEqual(big_void_1.compare(btc_spctr),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_1.compare(btc_spct_bad),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_1.compare(t1),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_1.compare(t2),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_2.compare(btc_spctr),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_2.compare(btc_spct_bad),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_2.compare(t1),
NeuralTypeComparisonResult.SAME)
self.assertEqual(big_void_2.compare(t2),
NeuralTypeComparisonResult.SAME)
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
# 'encoder_outputs': NeuralType(
# {0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag),}, optional=True,
# )
"encoder_outputs":
NeuralType(('B', 'T', 'D'), ChannelType(), optional=True)
}
def input_ports(self):
"""Returns definitions of module input ports.
decision:
0: AxisType(BatchTag)
1: AxisType(ChannelTag, 1)
"""
return {
# "decision": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag, 1)}),
"decision": NeuralType(('B', 'D'), ChannelType())
}
def test_infer_errors(self):
data_source = nemo.backends.pytorch.common.ZerosDataLayer(
size=1,
dtype=torch.FloatTensor,
batch_size=1,
output_ports={
"dl_out":
NeuralType((AxisType(
AxisKind.Batch), AxisType(AxisKind.Dimension, 1)),
ChannelType())
},
)
addten = AddsTen()
minusten = SubtractsTen()
zero_tensor = data_source()
ten_tensor = addten(mod_in=zero_tensor)
twenty_tensor = addten(mod_in=ten_tensor)
thirty_tensor = addten(mod_in=twenty_tensor)
with self.assertRaisesRegex(ValueError,
"use_cache was set, but cache was empty"):
evaluated_tensors = self.nf.infer(
tensors=[twenty_tensor, thirty_tensor],
verbose=False,
use_cache=True)
new_ten_tensor = minusten(mod_in=twenty_tensor)
evaluated_tensors = self.nf.infer(tensors=[new_ten_tensor],
verbose=False,
cache=True)
with self.assertRaisesRegex(ValueError,
"cache was set but was not empty"):
evaluated_tensors = self.nf.infer(
tensors=[twenty_tensor, thirty_tensor],
verbose=False,
cache=True)
self.nf.clear_cache()
evaluated_tensors = self.nf.infer(tensors=[new_ten_tensor],
verbose=False,
cache=True)
with self.assertRaisesRegex(ValueError,
"cache and use_cache were both set."):
evaluated_tensors = self.nf.infer(
tensors=[twenty_tensor, thirty_tensor],
verbose=False,
cache=True,
use_cache=True)
self.assertEqual(evaluated_tensors[0][0].squeeze().data, 10)
def input_types(self) -> Optional[Dict[str, NeuralType]]:
return {
"input_ids": NeuralType(('B', 'T'), ChannelType()),
"token_type_ids": NeuralType(('B', 'T'),
ChannelType(),
optional=True),
"attention_mask": NeuralType(('B', 'T'), MaskType(),
optional=True),
"labels": NeuralType(('B', 'T'), ChannelType(), optional=True),
'past_key_values':
[[NeuralType(None, StringType(), optional=True)]],
'use_cache': NeuralType(None, VoidType(), optional=True),
'position_ids': NeuralType(('B', 'T'),
ChannelType(),
optional=True),
"return_dict": NeuralType(None, StringType(), optional=True),
"output_attentions": NeuralType(None, StringType(), optional=True),
"output_hidden_states": NeuralType(None,
StringType(),
optional=True),
"max_length": NeuralType(None, IntType(), optional=True),
}
def test_call_TaylorNet(self):
x_tg = NmTensor(
producer=None,
producer_args=None,
output_port_name=None,
ntype=NeuralType(elements_type=ChannelType(), axes=('B', 'D')),
)
tn = TaylorNet(dim=4)
# note that real port's name: x was used
y_pred = tn(x=x_tg)
self.assertEqual(y_pred.producer, tn)
self.assertEqual(y_pred.producer_args.get("x"), x_tg)
def test_call_TaylorNet(self):
x_tg = nemo.core.neural_modules.NmTensor(
producer=None,
producer_args=None,
name=None,
ntype=NeuralType(elements_type=ChannelType(), axes=('B', 'D')),
)
tn = nemo.backends.pytorch.tutorials.TaylorNet(dim=4)
# note that real port's name: x was used
y_pred = tn(x=x_tg)
self.assertEqual(y_pred.producer, tn)
self.assertEqual(y_pred.producer_args.get("x"), x_tg)
def test_list_of_lists(self):
T1 = NeuralType(
axes=(
AxisType(kind=AxisKind.Batch, size=None, is_list=True),
AxisType(kind=AxisKind.Time, size=None, is_list=True),
AxisType(kind=AxisKind.Dimension, size=32, is_list=False),
AxisType(kind=AxisKind.Dimension, size=128, is_list=False),
AxisType(kind=AxisKind.Dimension, size=256, is_list=False),
),
elements_type=ChannelType(),
)
T2 = NeuralType(
axes=(
AxisType(kind=AxisKind.Batch, size=None, is_list=False),
AxisType(kind=AxisKind.Time, size=None, is_list=False),
AxisType(kind=AxisKind.Dimension, size=32, is_list=False),
AxisType(kind=AxisKind.Dimension, size=128, is_list=False),
AxisType(kind=AxisKind.Dimension, size=256, is_list=False),
),
elements_type=ChannelType(),
)
# TODO: should this be incompatible instead???
assert T1.compare(T2), NeuralTypeComparisonResult.TRANSPOSE_SAME
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
# "latents": NeuralType(
# {
# 0: AxisType(BatchTag),
# 1: AxisType(ChannelTag, 64),
# 2: AxisType(HeightTag, 4),
# 3: AxisType(WidthTag, 4),
# }
# )
"latents": NeuralType(('B', 'C', 'H', 'W'), ChannelType())
}
def output_ports(self):
"""Returns definitions of module output ports.
"""
return {
# "image": NeuralType(
# {
# 0: AxisType(BatchTag),
# 1: AxisType(ChannelTag),
# 2: AxisType(HeightTag, 28),
# 3: AxisType(WidthTag, 28),
# }
# )
"image": NeuralType(('B', 'C', 'H', 'W'), ChannelType())
}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
"""Returns definitions of module output ports."""
return {
"example_id_num": NeuralType(('B', 'T'), ChannelType()),
"service_id": NeuralType(('B'), ChannelType()),
"utterance_ids": NeuralType(('B', 'T'), ChannelType()),
"token_type_ids": NeuralType(('B', 'T'),
ChannelType()), # utterance segment
"attention_mask": NeuralType(('B', 'T'),
ChannelType()), # utterance mask
"intent_status": NeuralType(('B'), LabelsType()),
"requested_slot_status": NeuralType(('B'), LabelsType()),
"categorical_slot_status": NeuralType(('B'), LabelsType()),
"categorical_slot_value_status": NeuralType(('B'), LabelsType()),
"noncategorical_slot_status": NeuralType(('B'), LabelsType()),
"noncategorical_slot_value_start": NeuralType(('B'), LabelsType()),
"noncategorical_slot_value_end": NeuralType(('B'), LabelsType()),
"start_char_idx": NeuralType(('B', 'T'), LabelsType()),
"end_char_idx": NeuralType(('B', 'T'), LabelsType()),
"task_mask": NeuralType(('B', 'T'), ChannelType()),
}
def input_types(self) -> Optional[Dict[str, NeuralType]]:
return {
"enc_taskname":
NeuralType(('B', 'T', 'C'), ChannelType(), optional=True),
}
def output_ports(self):
"""Returns definitions of module output ports.
hidden_states: output embedding
"""
return {"hidden_states": NeuralType(('B', 'T', 'D'), ChannelType())}
def output_ports(self):
"""Returns definitions of module output ports.
"""
# return {"decision": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag, 1)})}
return {"decision": NeuralType(('B', 'C'), ChannelType())}
def output_ports(self):
"""Returns definitions of module output ports."""
return dict(pred=NeuralType(('B', 'T', 'D'), ChannelType()), len=NeuralType(('B',), LengthsType()))
def output_ports(self):
"""Returns definitions of module output ports.
example_id_num (int): example ids
service_id (int): service ids
is_real_example (bool): flag to determine is the example is valid
utterance_ids (int): utterance ids
utterance_segment (int): Denotes the identity of the sequence. Takes values 0 (system utterance) and 1 (user utterance)
utterance_mask (int): Mask which takes the value 0 for padded tokens and 1 otherwise
categorical_slot_status (int): The status of each categorical slot in the service
cat_slot_status_mask(int): Masks out categorical status for padded cat slots, takes values 0 and 1
categorical_slot_values (int): The index of the correct value for each categorical slot
cat_slot_values_mask (int): Masks out categorical slots values for slots not used in the service, takes values 0 and 1
noncategorical_slot_status (int): The status of each non-categorical slot in the service
noncat_slot_status_mask(int): Masks out non-categorical status for padded cat slots, takes values 0 and 1
noncategorical_slot_value_start (int): The index of the starting subword corresponding to the slot span for a non-categorical slot value
noncategorical_slot_value_end (int): The index of the ending (inclusive) subword corresponding to the slot span for a non-categorical slot value
start_char_idx (int): Start character indices in the original utterance corresponding to the tokens
end_char_idx (int): Inclusive end character indices in the original utterance corresponding to the tokens
num_slots (int): Total number of slots present in the service
requested_slot_status (int): Takes value 1 if the corresponding slot is requested, 0 otherwise
req_slot_mask (int): Masks requested slots not used for the particular service
intent_status_mask (long): Masks out padded intents in the service, takes values 0 and 1
intent_status_labels (int): Intent labels
"""
return {
"example_id_num": NeuralType(('B'), ChannelType()),
"service_id": NeuralType(('B'), ChannelType()),
"is_real_example": NeuralType(('B'), ChannelType()),
"utterance_ids": NeuralType(('B', 'T'), ChannelType()),
"utterance_segment": NeuralType(('B', 'T'), ChannelType()),
"utterance_mask": NeuralType(('B', 'T'), ChannelType()),
"categorical_slot_status": NeuralType(('B', 'T'), LabelsType()),
"cat_slot_status_mask": NeuralType(('B', 'T'), ChannelType()),
"categorical_slot_values": NeuralType(('B', 'T'), LabelsType()),
"cat_slot_values_mask": NeuralType(('B', 'T', 'C'), ChannelType()),
"noncategorical_slot_status": NeuralType(('B', 'T'), LabelsType()),
"noncat_slot_status_mask": NeuralType(('B', 'T'), ChannelType()),
"noncategorical_slot_value_start": NeuralType(('B', 'T'),
LabelsType()),
"noncategorical_slot_value_end": NeuralType(('B', 'T'),
LabelsType()),
"start_char_idx": NeuralType(('B', 'T'), LabelsType()),
"end_char_idx": NeuralType(('B', 'T'), LabelsType()),
"num_slots": NeuralType(('B'), LengthsType()),
"requested_slot_status": NeuralType(('B', 'T'), LabelsType()),
"req_slot_mask": NeuralType(('B', 'T'), ChannelType()),
"intent_status_mask": NeuralType(('B', 'T'), ChannelType()),
"intent_status_labels": NeuralType(('B'), LabelsType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
# return {"input_ids": NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag)})}
return {"input_ids": NeuralType(('B', 'T'), ChannelType())}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
return {
'loss': NeuralType(None, FloatType(), optional=True),
'hidden_states': NeuralType(('B', 'T', 'D'), ChannelType()),
}
def input_types(self) -> Optional[Dict[str, NeuralType]]:
"""
Returns definitions of module input ports.
We implement it here since all NLP classifiers have the same inputs
"""
return {"hidden_states": NeuralType(('B', 'T', 'D'), ChannelType())}
def output_ports(self):
"""Returns definitions of module output ports.
"""
# return {"hidden_states": NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)})}
return {"hidden_states": NeuralType(('B', 'T', 'D'), ChannelType())}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
return {"output_embeds": NeuralType(('B', 'T', 'C'), ChannelType())}
