def test_cat_classification(model):
print("\n--- Test cat classification (%s) ---" % model)
filename = "assets/cat.jpg"
intermediate = DeepNetwork(filename=model)
class_name = intermediate.predict(imread(filename))
print("Model selected class '{0}' for image {1}".format(
class_name, filename))
def convert(torch_model, class_map, description="Neural Network Model"):
"""
Convert a torch model to PMML
@model. The torch model object
@class_map. A map in the form {class_id: class_name}
@description. A short description of the model
Returns a DeepNeuralNetwork object which can be exported to PMML
"""
pmml = DeepNetwork(description=description, class_map=class_map)
pmml.torch_model = torch_model
pmml.model_name = str(torch_model)
layers = serialize_layers(torch_model, '')
# Attach the first layer
previous_layer = convert_input()
pmml._append_layer(previous_layer)
# Attach the following layers
flattened = False
for identifier, layer in layers:
print(layer.__class__)
if layer.__class__ in CONVERSIONS:
if layer.__class__ == nn.Linear and not flattened:
previous_layer = convert_flatten(previous_layer)
pmml._append_layer(previous_layer)
flattened = True
converter = CONVERSIONS[layer.__class__]
previous_layer = converter(identifier, layer, previous_layer)
pmml._append_layer(previous_layer)
elif layer.__class__ == Bottleneck:
pmml, previous_layer = convert_bottleneck(pmml, identifier, layer,
previous_layer)
else:
pass
# raise ValueError("Unknown layer type:", layer.__class__)
return pmml
def test_intermediate_to_keras(pmml_file, keras_model):
"""
Test conversion between intermediate form and keras
Compare the loaded PMML file to @keras_model
"""
print("\n--- Test Intermediate to Keras (%s) ---" % pmml_file)
intermediate = DeepNetwork(filename=pmml_file)
new_keras_model = intermediate.get_keras_model()
new_config = new_keras_model.get_config()
old_config = keras_model.get_config()
def convert(torch_model, class_map, description="Neural Network Model"):
"""
Convert a torch model to PMML
@model. The torch model object
@class_map. A map in the form {class_id: class_name}
@description. A short description of the model
Returns a DeepNeuralNetwork object which can be exported to PMML
"""
pmml = DeepNetwork(description=description, class_map=class_map)
pmml.torch_model = torch_model
pmml.model_name = str(torch_model)
first_layer = convert_input()
last_layer = convert_recursive(torch_model, first_layer, pmml)
def convert_torch_to_pmml(torch_model,
output_path,
weights_path,
description,
debug=True):
"""
Convert a torch model to PMML
"""
print("\nGenerating model: %s" % description)
class_map = load_imagenet_classes()
pmml = convert(torch_model, class_map=class_map, description=description)
pmml.save_pmml(output_path, weights_path=weights_path, save_weights=False)
if debug:
print("Checking model: %s" % output_path)
intermediate = DeepNetwork(filename=output_path)
old_config = torch_model.get_config()
new_config = intermediate.get_keras_model().get_config()
directory = os.path.dirname(output_path)
dump_config(old_config, new_config, directory)
test_prediction(output_path, "assets/cat.jpg")
def test_prediction(output_path, image_path):
intermediate = DeepNetwork(filename=output_path)
class_name = intermediate.predict(imread(image_path))
print("Model selected class '{0}' for image {1}".format(
class_name, intermediate.description))
def convert(keras_model, class_map, description="Neural Network Model"):
"""
Convert a keras model to PMML
@model. The keras model object
@class_map. A map in the form {class_id: class_name}
@description. A short description of the model
Returns a DeepNeuralNetwork object which can be exported to PMML
"""
pmml = DeepNetwork(description=description, class_map=class_map)
pmml.keras_model = keras_model
pmml.model_name = keras_model.name
config = keras_model.get_config()
for layer in config['layers']:
layer_class = layer['class_name']
layer_config = layer['config']
layer_inbound_nodes = layer['inbound_nodes']
# Input
if layer_class is "InputLayer":
pmml._append_layer(
InputLayer(name=layer_config['name'],
input_size=layer_config['batch_input_shape'][1:]))
# Conv2D
elif layer_class is "Conv2D":
pmml._append_layer(
Conv2D(
name=layer_config['name'],
channels=layer_config['filters'],
kernel_size=layer_config['kernel_size'],
dilation_rate=layer_config['dilation_rate'],
use_bias=layer_config['use_bias'],
activation=layer_config['activation'],
strides=layer_config['strides'],
padding=layer_config['padding'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# DepthwiseConv2D
elif layer_class is "DepthwiseConv2D":
pmml._append_layer(
DepthwiseConv2D(
name=layer_config['name'],
kernel_size=layer_config['kernel_size'],
depth_multiplier=layer_config['depth_multiplier'],
use_bias=layer_config['use_bias'],
activation=layer_config['activation'],
strides=layer_config['strides'],
padding=layer_config['padding'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# MaxPooling
elif layer_class is "MaxPooling2D":
pmml._append_layer(
MaxPooling2D(
name=layer_config['name'],
pool_size=layer_config['pool_size'],
strides=layer_config['strides'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
elif layer_class is "AveragePooling2D":
pmml._append_layer(
AveragePooling2D(
name=layer_config['name'],
pool_size=layer_config['pool_size'],
strides=layer_config['strides'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
elif layer_class is "GlobalAveragePooling2D":
pmml._append_layer(
GlobalAveragePooling2D(
name=layer_config['name'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Flatten
elif layer_class is "Flatten":
pmml._append_layer(
Flatten(
name=layer_config['name'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Dense
elif layer_class is "Dense":
pmml._append_layer(
Dense(
name=layer_config['name'],
channels=layer_config['units'],
use_bias=layer_config['use_bias'],
activation=layer_config['activation'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Zero padding layer
elif layer_class is "ZeroPadding2D":
pmml._append_layer(
ZeroPadding2D(
name=layer_config['name'],
padding=layer_config['padding'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Reshape layer
elif layer_class is "Reshape":
pmml._append_layer(
Reshape(
name=layer_config['name'],
target_shape=layer_config['target_shape'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
elif layer_class is "Dropout":
pmml._append_layer(
Dropout(
name=layer_config['name'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Batch Normalization
elif layer_class is "BatchNormalization":
pmml._append_layer(
BatchNormalization(
name=layer_config['name'],
axis=layer_config['axis'],
momentum=layer_config['momentum'],
epsilon=layer_config['epsilon'],
center=layer_config['center'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
elif layer_class is "Add":
pmml._append_layer(
Merge(name=layer_config['name'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes)))
elif layer_class is "Subtract":
pmml._append_layer(
Merge(name=layer_config['name'],
operator='subtract',
inbound_nodes=get_inbound_nodes(layer_inbound_nodes)))
elif layer_class is "Dot":
pmml._append_layer(
Merge(name=layer_config['name'],
operator='dot',
inbound_nodes=get_inbound_nodes(layer_inbound_nodes)))
elif layer_class is "Concatenate":
pmml._append_layer(
Merge(name=layer_config['name'],
axis=layer_config['axis'],
operator='concatenate',
inbound_nodes=get_inbound_nodes(layer_inbound_nodes)))
elif layer_class is "Activation":
pmml._append_layer(
Activation(
name=layer_config['name'],
activation=layer_config['activation'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
elif layer_class is "ReLU":
pmml._append_layer(
Activation(
name=layer_config['name'],
activation='relu',
threshold=layer_config['threshold'],
max_value=layer_config['max_value'],
negative_slope=layer_config['negative_slope'],
inbound_nodes=get_inbound_nodes(layer_inbound_nodes),
))
# Unknown layer
else:
raise ValueError("Unknown layer type:", layer_class)
return pmml
def test_pmml_to_intermediate():
"""
Load an PMML file to an intermediate form
"""
print("\n--- Test PMML to intermediate ---")
intermediate = DeepNetwork(filename=VGG_16_MODEL)