def read_learning_info(pb: io.BufferedReader):
while True:
read_placeholder(pb, 1)
first_char = pb.read(1)
pb.seek(-2, os.SEEK_CUR)
position = pb.tell()
if first_char == b'L':
cur_pos = pb.tell()
token = find_next_tag(pb)
pb.seek(cur_pos)
if token in ['<LearnRateCoef>', '<LearningRate>']:
token = bytes(token, 'ascii')
else:
log.debug('Unexpected tag: {}'.format(token))
break
elif first_char == b'B':
token = b'<BiasLearnRateCoef>'
elif first_char == b'M':
token = b'<MaxNorm>'
elif first_char == b'!': # token = b'<EndOfComponent>'
break
else:
break
try:
read_token_value(pb, token)
except Error:
pb.seek(position)
break
def extract(cls, node: Node) -> bool:
"""
Extract conv parameters from node.parameters.
node.parameters like file descriptor object.
:param node: Convolution node
:return:
"""
pb = node.parameters
kernel = read_token_value(pb, b'<PatchDim>')
stride = read_token_value(pb, b'<PatchStep>')
patch_stride = read_token_value(pb, b'<PatchStride>')
read_learning_info(pb)
collect_until_whitespace(pb)
weights, weights_shape = read_binary_matrix(pb)
collect_until_whitespace(pb)
biases = read_binary_vector(pb)
if (patch_stride - kernel) % stride != 0:
raise Error(
'Kernel size and stride does not correspond to `patch_stride` attribute of Convolution layer. ' +
refer_to_faq_msg(93))
output = biases.shape[0]
if weights_shape[0] != output:
raise Error('Weights shape does not correspond to the `output` attribute of Convolution layer. ' +
refer_to_faq_msg(93))
mapping_rule = {
'output': output,
'patch_stride': patch_stride,
'bias_term': None,
'pad': np.array([[0, 0], [0, 0], [0, 0], [0, 0]], dtype=np.int64),
'pad_spatial_shape': np.array([[0, 0], [0, 0]], dtype=np.int64),
'dilation': np.array([1, 1, 1, 1], dtype=np.int64),
'kernel': np.array([1, 1, 1, kernel], dtype=np.int64),
'stride': np.array([1, 1, 1, stride], dtype=np.int64),
'kernel_spatial': np.array([1, kernel], dtype=np.int64),
'input_feature_channel': 1,
'output_feature_channel': 0,
'kernel_spatial_idx': [2, 3],
'group': 1,
'reshape_kernel': True,
}
mapping_rule.update(layout_attrs())
embed_input(mapping_rule, 1, 'weights', weights)
embed_input(mapping_rule, 2, 'biases', biases)
mapping_rule['bias_addable'] = len(biases) > 0
Convolution.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
pb = node.parameters
collect_until_token(pb, b'<ConvolutionModel>')
in_shape = read_token_value(pb, b'<NumFiltersIn>')
out_shape = read_token_value(pb, b'<NumFiltersOut>')
height_in = read_token_value(pb, b'<HeightIn>')
height_out = read_token_value(pb, b'<HeightOut>')
height_subsample = read_token_value(pb, b'<HeightSubsampleOut>')
collect_until_token(pb, b'<Offsets>')
offsets = read_binary_vector_of_pairs(pb,
read_token=False,
dtype=np.int32)
collect_until_token(pb, b'<RequiredTimeOffsets>')
time_offsets = read_binary_vector(pb, read_token=False, dtype=np.int32)
collect_until_token(pb, b'<LinearParams>')
weights, _ = read_binary_matrix(pb)
collect_until_token(pb, b'<BiasParams>')
biases = read_binary_vector(pb)
offsets = offsets.reshape([len(offsets) // 2, 2])
mapping_rule = { # stride for h axis
'height_subsample': height_subsample,
# input dimension for h axis
'height_in': height_in,
# output dimension for h axis
'height_out': height_out,
# input dimension for channel axis
'in_channels': in_shape,
# output dimension for channel axis
'out_channels': out_shape,
# array with pairs like the following
# [ (-1, -1) (-1, 0) (-1, 1)
# (0, -1) (0, 0) (0, 1)
# (1, -1) (1, 0) (1, 1)]
# it means that kernel 3x3 will be applied to calculate current value of output
'offsets': offsets,
# required time offsets to calculate current convolution
# time_offsets = [-1, 0, 1] for previous example means no padding for time axis and
# 3 values should be prepared
# time_offsets = [0] means zero padding [1, 1] for time axis
'time_offsets': time_offsets,
'out-size': out_shape * height_out
}
embed_input(mapping_rule, 1, 'weights', weights)
embed_input(mapping_rule, 2, 'biases', biases)
TimeHeightConvolutionComponent.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
pb = node.parameters
collect_until_token(pb, b'<PoolSize>')
kernel = read_binary_integer32_token(pb)
tag = find_next_tag(pb)
if tag == '<PoolStep>':
read_placeholder(pb, 1)
stride = read_binary_integer32_token(pb)
pool_step = stride
pool_stride = read_token_value(pb, b'<PoolStride>')
elif tag == '<PoolStride>':
stride = 1
pool_step = None
read_placeholder(pb, 1)
pool_stride = read_binary_integer32_token(pb)
else:
raise Error('Can not extract parameters for {}'.format(node))
mapping_rule = {
'window': np.array([1, 1, 1, kernel], dtype=np.int64),
'stride': np.array([1, 1, 1, stride], dtype=np.int64),
'pool_stride': pool_stride,
'pool_step': pool_step,
'pad': np.array([[0, 0], [0, 0], [0, 0], [0, 0]], dtype=np.int64),
'pad_spatial_shape': np.array([[0, 0], [0, 0]], dtype=np.int64),
'pool_method': 'max',
}
mapping_rule.update(layout_attrs())
Pooling.update_node_stat(node, mapping_rule)
return cls.enabled
def load_kalid_nnet2_model(graph, file_descr, nnet_name):
input_name = 'Input'
graph.add_node(input_name,
name=input_name,
kind='op',
op='Parameter',
parameters=None,
shape=None)
prev_layer_id = input_name
all_components = load_components(file_descr, graph)
used_layers = set()
for layer_id in all_components:
prev_node = Node(graph, prev_layer_id)
if prev_node.op == 'Parameter':
parameters = Node(graph, layer_id).parameters
input_dim = read_token_value(parameters, b'<InputDim>')
prev_node['shape'] = np.array([1, input_dim], dtype=np.int64)
prev_node.add_output_port(0)
Node(graph, layer_id).add_input_port(0)
graph.create_edge(
prev_node, Node(graph, layer_id), 0, 0,
create_edge_attrs(prev_layer_id, layer_id, prev_layer_id))
used_layers.add(prev_layer_id)
prev_layer_id = layer_id
log.debug('{} and {} were connected'.format(prev_layer_id, layer_id))
# Tensor names information corresponding to a node is stored on outgoing edges.
# As output nodes do not have outgoing edges, fake outputs are required. In the following code
# for each output Identity node is added, and tensor name for the output is kept
# on (output, fake output) edge. After Result nodes adding transformation fake outputs
# are deleted from graph.
output_layers = graph.nodes - used_layers
add_outputs_identity(
graph, output_layers, lambda g, output, fake_output: g.create_edge(
Node(g, output), Node(g, fake_output), 0, 0,
create_edge_attrs(output, fake_output, output)))
def load_parallel_component(file_descr, graph: Graph, prev_layer_id):
"""
Load ParallelComponent of the Kaldi model.
ParallelComponent contains parallel nested networks.
VariadicSplit is inserted before nested networks.
Outputs of nested networks concatenate with layer Concat.
:param file_descr: descriptor of the model file
:param graph: graph with the topology.
:param prev_layer_id: id of the input layers for parallel component layer
:return: id of the concat layer - last layer of the parallel component layers
"""
nnet_count = read_token_value(file_descr, b'<NestedNnetCount>')
log.debug(
'Model contains parallel component with {} nested networks'.format(
nnet_count))
split_points = []
outputs = []
inputs = []
for i in range(nnet_count):
read_token_value(file_descr, b'<NestedNnet>')
collect_until_token(file_descr, b'<Nnet>')
g = Graph()
load_kalid_nnet1_model(g, file_descr, 'Nested_net_{}'.format(i))
# input to nnet1 models is of a rank 1 but we also insert batch_size to 0th axis
# 1st axis contains input_size of the nested subnetwork
# we split input from the main network to subnetworks
input_node = Node(g, 'Parameter')
split_points.append(input_node['shape'][1])
g.remove_node(input_node.id)
mapping = {
node: graph.unique_id(node)
for node in g.nodes(data=False) if node in graph
}
g = nx.relabel_nodes(g, mapping)
for val in mapping.values():
g.node[val]['name'] = val
graph.add_nodes_from(g.nodes(data=True))
graph.add_edges_from(g.edges(data=True))
sorted_nodes = tuple(nx.topological_sort(g))
outputs.append(Node(graph, sorted_nodes[-1]))
inputs.append(Node(graph, sorted_nodes[0]))
split_id = graph.unique_id(prefix='NestedNets/VariadicSplit')
attrs = {
'out_ports_count': nnet_count,
'size_splits': split_points,
'axis': 1,
'name': split_id
}
variadic_split_node = AttributedVariadicSplit(graph, attrs).create_node()
prev_layer_node = Node(graph, prev_layer_id)
prev_layer_node.add_output_port(0)
graph.create_edge(
prev_layer_node, variadic_split_node, 0, 0,
create_edge_attrs(prev_layer_id, variadic_split_node.id,
prev_layer_id))
concat_id = graph.unique_id(prefix='Concat')
graph.add_node(concat_id, parameters=None, op='concat', kind='op')
concat_node = Node(graph, concat_id)
# Connect each output of variadic_split_node to each subnetwork's inputs in ParallelComponent
# and each subnetwork's output to concat_node
for i, (input_node, output_node) in enumerate(zip(inputs, outputs)):
output_node.add_output_port(0)
concat_node.add_input_port(i)
graph.create_edge(
output_node, concat_node, 0, i,
create_edge_attrs(output_node.id, concat_id, output_node.id, i, 0))
graph.create_edge(
variadic_split_node, input_node, i, 0,
create_edge_attrs(variadic_split_node.id, input_node.id,
variadic_split_node.id, 0, i))
return concat_id