def _neural_network_nodes_and_edges(nn_spec, cy_nodes, cy_edges, spec_outputs,
input_spec):
"""
Parameters
----------
nn_spec : Neural Network Spec
cy_nodes : list to add nn nodes to
cy_edges : list to add edges for nn nodes to
spec_outputs : outputs of nn spec
input_spec : input spec of Neural Network
Returns
-------
cy_data : concatenated list of updated cy_nodes and cy_edges
"""
cy_nodes = _neural_network_node_info(nn_spec, cy_nodes)
cy_nodes.append({
'data': {
'id': 'output_node',
'name': '',
'info': {
'type': 'output node'
},
'classes': 'output',
}
})
for model_output, output_type in spec_outputs:
cy_nodes.append({
'data': {
'id': str(model_output),
'name': str(model_output),
'info': {
'type': "\n".join(str(output_type).split("\n")),
'inputs': str([model_output]),
'outputs': str([])
},
'parent': 'output_node'
},
'classes': 'output'
})
shape_dict = _infer_shapes(nn_spec, input_spec)
cy_nodes, cy_edges = _calculate_edges(cy_nodes, cy_edges, shape_dict)
cy_data = cy_nodes + cy_edges
return cy_data
def inspect(model_path, output_txt_file):
spec = coremltools.utils.load_spec(model_path)
sys.stdout = open(os.devnull, "w")
shape_dict = _infer_shapes(model_path)
sys.stdout = sys.__stdout__
types_dict = {}
sys.stdout = open(output_txt_file, 'w')
nn = spec.neuralNetwork
if spec.WhichOneof('Type') == 'neuralNetwork':
nn = spec.neuralNetwork
elif spec.WhichOneof('Type') == 'neuralNetworkRegressor':
nn = spec.neuralNetworkRegressor
elif spec.WhichOneof('Type') == 'neuralNetworkClassifier':
nn = spec.neuralNetworkClassifier
else:
raise ValueError("Only neural network model Type is supported")
for i, layer in enumerate(nn.layers):
print(
'---------------------------------------------------------------------------------------------------------------------------------------------'
)
print("{}: layer name = {}, layer type = ( {} ), \n inputs = \n {}, \n input shapes = {}, \n outputs = \n {}, \n output shapes = {} ".format(i, layer.name, \
layer.WhichOneof('layer'), ", ".join([x for x in layer.input]), ", ".join([str(shape_dict[x]) for x in layer.input]),
", ".join([x for x in layer.output]),
", ".join([str(shape_dict[x]) for x in layer.output])))
layer_type = layer.WhichOneof('layer')
if layer_type == 'convolution' and layer.convolution.isDeconvolution:
layer_type = 'deconvolution'
if layer_type in types_dict:
types_dict[layer_type] += 1
else:
types_dict[layer_type] = 1
print(
'---------------------------------------------------------------------------------------------------------------------------------------------'
)
sorted_types_count = sorted(types_dict.items(), key=operator.itemgetter(1))
print('Layer Type counts:')
for i in sorted_types_count:
print("{} : {}".format(i[0], i[1]))
def _neural_network_nodes_and_edges(nn_spec,
cy_nodes,
cy_edges,
spec_outputs,
input_spec
):
"""
Parameters
----------
nn_spec : Neural Network Spec
cy_nodes : list to add nn nodes to
cy_edges : list to add edges for nn nodes to
spec_outputs : outputs of nn spec
input_spec : input spec of Neural Network
Returns
-------
cy_data : concatenated list of updated cy_nodes and cy_edges
"""
cy_nodes = _neural_network_node_info(nn_spec, cy_nodes)
cy_nodes.append({
'data': {
'id': 'output_node',
'name': 'output_node',
'info': {
'inputs': str(spec_outputs),
'outputs': str([])
},
'classes': 'output',
}
})
shape_dict = _infer_shapes(nn_spec, input_spec)
cy_nodes, cy_edges = _calculate_edges(cy_nodes, cy_edges, shape_dict)
cy_data = cy_nodes + cy_edges
return cy_data
def _pipeline_nodes_and_edges(cy_nodes, cy_edges, pipeline_spec, spec_outputs):
"""
Parameters
----------
cy_nodes : list to add nn nodes to
cy_edges : list to add edges for nn nodes to
pipeline_spec: Spec of pipeline mlmodel
spec_outputs: spec outputs of pipeline mlmodel
Returns
-------
cy_data : concatenated list of updated cy_nodes and cy_edges
"""
i = 1
nn_model_types = ['neuralNetwork', 'neuralNetworkClassifier', 'neuralNetworkRegressor']
models = pipeline_spec.models
shape_dict = None
for model in models:
sub_model_type = model.WhichOneof('Type')
info = {}
input_names = []
output_names = []
info['Pipeline Component'] = sub_model_type.upper()
for model_input in model.description.input:
input_names.append(model_input.name)
info['inputs'] = str(input_names)
for model_output in model.description.output:
output_names.append(model_output.name)
info['outputs'] = str(output_names)
info = _pipeline_component_info(model, info)
if sub_model_type in nn_model_types:
cy_nodes.append({
'data': {
'id': "{}_{}".format(sub_model_type, i),
'name': sub_model_type,
'info': info
},
'classes': 'parent',
})
if sub_model_type == 'neuralNetwork':
nn_spec = model.neuralNetwork
elif sub_model_type == 'neuralNetworkClassifier':
nn_spec = model.neuralNetworkClassifier
elif sub_model_type == 'neuralNetworkRegressor':
nn_spec = model.neuralNetworkRegressor
cy_nodes = _neural_network_node_info(nn_spec, cy_nodes, child=True, parent="{}_{}".format(sub_model_type, i))
shape_dict = _infer_shapes(nn_spec, model.description.input)
else:
cy_nodes.append({
'data': {
'id': "{}_{}".format(sub_model_type, i),
'name': sub_model_type,
'info': info
},
'classes': sub_model_type
})
i += 1
cy_nodes.append({
'data': {
'id': 'output_node',
'name': 'output_node',
'info': {
'inputs': str(spec_outputs),
'outputs': str([])
},
'classes': 'output',
}
})
cy_nodes, cy_edges = _calculate_edges(cy_nodes, cy_edges, shape_dict)
cy_data = cy_nodes + cy_edges
return cy_data