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.
"""
# TODO output type for external features
output_types = {
'external_feat':
NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
'feat_length':
NeuralType(tuple('B'), LengthsType()),
}
if self.is_speaker_emb:
output_types.update({
'embs':
NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
'embs_length':
NeuralType(tuple('B'), LengthsType()),
'label':
NeuralType(('B', 'T'), LabelsType()),
'label_length':
NeuralType(tuple('B'), LengthsType()),
})
else:
output_types.update({
'label':
NeuralType(('B', 'T'), LabelsType()),
'label_length':
NeuralType(tuple('B'), LengthsType()),
})
return output_types
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()),
"subtokens_mask": NeuralType(("B", "T"), MaskType()),
"loss_mask": NeuralType(("B", "T"), MaskType()),
"punct_labels": NeuralType(("B", "T"), LabelsType()),
"capit_labels": NeuralType(("B", "T"), LabelsType()),
}
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()),
'subtokens_mask': NeuralType(('B', 'T'), MaskType()),
'loss_mask': NeuralType(('B', 'T'), MaskType()),
'punct_labels': NeuralType(('B', 'T'), LabelsType()),
'capit_labels': NeuralType(('B', 'T'), LabelsType()),
}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
"""Returns definitions of module output ports.
"""
return {
"input_ids": NeuralType(('B', 'T'), ChannelType()),
"input_mask": NeuralType(('B', 'T'), MaskType()),
"segment_ids": NeuralType(('B', 'T'), ChannelType()),
"labels_mask": NeuralType(('B', 'T'), MaskType()),
"tag_labels": NeuralType(('B', 'T'), LabelsType()),
"semiotic_labels": NeuralType(('B', 'T'), LabelsType()),
"semiotic_spans": NeuralType(('B', 'T', 'C'), IntType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
encoder_hidden: hidden states of the encoder
encoder_outputs: outputs of the encoder
input_lens: lengths of the input sequences to encoder
src_ids: input sequences to encoder
targets: targets for the output of the generator
"""
return {
# 'encoder_hidden': NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}),
# 'encoder_outputs': NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag), 2: AxisType(ChannelTag)}),
# 'input_lens': NeuralType({0: AxisType(BatchTag)}),
# 'src_ids': NeuralType({0: AxisType(BatchTag), 1: AxisType(TimeTag)}),
# 'targets': NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(TimeTag)}),
'encoder_hidden': NeuralType(('B', 'T', 'C'), ChannelType()),
'encoder_outputs': NeuralType(('B', 'T', 'C'), ChannelType()),
'input_lens': NeuralType(tuple('B'), LengthsType()),
'src_ids': NeuralType(('B', 'T'), ChannelType()),
# 'targets': NeuralType(ChannelType(), ('B', 'D', 'T')),
'targets': NeuralType(('B', 'D', 'T'), LabelsType()),
}
def output_types(self) -> Optional[Dict[str, NeuralType]]:
"""Returns definitions of module output ports.
"""
output_types = {
'audio_signal':
NeuralType(
('B', 'T'),
AudioSignal(freq=self._sample_rate) if self is not None
and hasattr(self, '_sample_rate') else AudioSignal(),
),
'a_sig_length':
NeuralType(tuple('B'), LengthsType()),
}
if self.is_regression_task:
output_types.update({
'targets':
NeuralType(tuple('B'), RegressionValuesType()),
'targets_length':
NeuralType(tuple('B'), LengthsType()),
})
else:
output_types.update({
'label':
NeuralType(tuple('B'), LabelsType()),
'label_length':
NeuralType(tuple('B'), LengthsType()),
})
return output_types
def input_types(self) -> Optional[Dict[str, NeuralType]]:
return {
"input_ids": NeuralType(('B', 'T'), ChannelType()),
"decoder_input_ids": NeuralType(('B', 'T'), ChannelType()),
"attention_mask": NeuralType(('B', 'T'), MaskType(), optional=True),
"labels": NeuralType(('B', 'T'), LabelsType()),
}
def output_ports(self):
"""Returns definitions of module output ports.
"""
return {
# "latent": NeuralType(
# {
# 0: AxisType(BatchTag),
# 1: AxisType(ChannelTag, 64),
# 2: AxisType(HeightTag, 4),
# 3: AxisType(WidthTag, 4),
# }
# ),
# "image": NeuralType(
# {
# 0: AxisType(BatchTag),
# 1: AxisType(ChannelTag),
# 2: AxisType(HeightTag, self._input_size[1]),
# 3: AxisType(WidthTag, self._input_size[0]),
# }
# ),
# "label": NeuralType({0: AxisType(BatchTag)}),
"latent": NeuralType(('B', 'C', 'H', 'W'), ChannelType()),
"image": NeuralType(('B', 'C', 'H', 'W'), ChannelType()),
"label": NeuralType(tuple('B'), LabelsType()),
}
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"logits": NeuralType(('B', 'D'), LogitsType()),
"labels": NeuralType(('B'), LabelsType())
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
"logits": NeuralType(axes=('B', 'D'), elements_type=LogitsType()),
"labels": NeuralType(axes=tuple('B'), elements_type=LabelsType()),
}
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"preds": NeuralType(tuple('B'), RegressionValuesType()),
"labels": NeuralType(tuple('B'), LabelsType()),
}
def input_types(self):
"""Input types definitions for AnguarLoss.
"""
return {
"logits": NeuralType(('B', 'D'), LogitsType()),
"labels": NeuralType(('B',), LabelsType()),
}
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"targets": NeuralType(('B', 'T'), LabelsType()),
"target_length": NeuralType(tuple('B'), LengthsType()),
"states": [NeuralType(('D', 'B', 'D'), ElementType(), optional=True)], # must always be last
}
def input_types(self):
return OrderedDict(
{
"encoder_output": NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
"targets": NeuralType(('B', 'T'), LabelsType()),
"target_lengths": NeuralType(tuple('B'), LengthsType()),
}
)
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"log_probs": NeuralType(("B", "T", "D"), LogprobsType()),
"labels": NeuralType(("B", "T"), LabelsType()),
"output_mask": NeuralType(("B", "T"), MaskType(), optional=True),
}
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_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 input_types(self):
"""Input types definitions for LatticeLoss.
"""
return {
"log_probs": NeuralType(("B", "T", "D"), LogprobsType()),
"targets": NeuralType(("B", "T"), LabelsType()),
"input_lengths": NeuralType(tuple("B"), LengthsType()),
"target_lengths": NeuralType(tuple("B"), LengthsType()),
}
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
"""
return {
"src_ids": NeuralType(('B', 'T'), TokenIndex()),
"src_lens": NeuralType(tuple('B'), Length()),
"tgt_ids": NeuralType(('B', 'D', 'T'), LabelsType()),
"tgt_lens": NeuralType(('B', 'D'), Length()),
"gating_labels": NeuralType(('B', 'D'), LabelsType()),
"turn_domain": NeuralType(),
}
def input_types(self):
"""Input types definitions for CTCLoss.
"""
return {
"log_probs": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
"targets": NeuralType(('B', 'T'), LabelsType()),
"input_lengths": NeuralType(tuple('B'), LengthsType()),
"target_lengths": NeuralType(tuple('B'), LengthsType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
# "logits": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag), 2: AxisType(ChannelTag)}),
# "labels": NeuralType({0: AxisType(BatchTag), 1: AxisType(ChannelTag)}),
"logits": NeuralType(('B', 'D', 'D'), LogitsType()),
"labels": NeuralType(('B', 'D'), LabelsType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
'encoder_hidden': NeuralType(('B', 'T', 'C'), ChannelType()),
'encoder_outputs': NeuralType(('B', 'T', 'C'), ChannelType()),
'input_lens': NeuralType(tuple('B'), LengthsType()),
'src_ids': NeuralType(('B', 'T'), ChannelType()),
'targets': NeuralType(('B', 'D', 'T'), LabelsType()),
}
def input_types(self):
state_type = NeuralType(('D', 'B', 'D'), ElementType())
mytypes = {
'encoder_outputs': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
"targets": NeuralType(('B', 'T'), LabelsType()),
"target_length": NeuralType(tuple('B'), LengthsType()),
'input-states-1': state_type,
'input-states-2': state_type,
}
return mytypes
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"encoder_outputs": NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
"decoder_outputs": NeuralType(('B', 'D', 'T'), EmbeddedTextType()),
"encoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
"transcripts": NeuralType(('B', 'T'), LabelsType(), optional=True),
"transcript_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
"compute_wer": NeuralType(optional=True),
}
def input_ports(self):
"""Returns definitions of module input ports.
preds:
0: AxisType(RegressionTag)
labels:
0: AxisType(RegressionTag)
"""
return {
"preds": NeuralType(tuple('B'), RegressionValuesType()),
"labels": NeuralType(tuple('B'), LabelsType()),
}
def input_ports(self):
"""Returns definitions of module input ports.
"""
return {
"logits":
NeuralType(['B'] + ['ANY'] * (self._logits_dim - 1), LogitsType()),
"labels":
NeuralType(['B'] + ['ANY'] * (self._logits_dim - 2), LabelsType()),
"loss_mask":
NeuralType(['B'] + ['ANY'] * (self._logits_dim - 2),
MaskType(),
optional=True),
}
def input_types(self):
"""Input types definitions for Contrastive.
"""
return {
"spec_masks": NeuralType(("B", "D", "T"), SpectrogramType()),
"decoder_outputs": NeuralType(("B", "T", "D"), VoidType()),
"targets": NeuralType(('B', 'T'), LabelsType()),
"decoder_lengths": NeuralType(tuple('B'),
LengthsType(),
optional=True),
"target_lengths": NeuralType(tuple('B'),
LengthsType(),
optional=True),
}
def input_ports(self):
"""Returns definitions of module input ports.
logits: 4d tensor of logits
labels: 3d tensor of labels
loss_mask: specifies the words to be considered in the loss calculation
"""
return {
"logits": NeuralType(('B', 'T', 'D', 'D'), LogitsType()),
"labels": NeuralType(('B', 'D', 'T'), LabelsType()),
"length_mask": NeuralType(('B', 'D'), LengthsType()),
}
def input_types(self):
"""Returns definitions of module input ports.
"""
return {
"logits":
NeuralType(["B"] + ["ANY"] * (self._logits_dim - 1), LogitsType()),
"labels": [
NeuralType(["B"] + ["ANY"] * (self._logits_dim - 2),
LabelsType())
],
"loss_mask":
NeuralType(["B"] + ["ANY"] * (self._logits_dim - 2),
MaskType(),
optional=True),
}
