def SaveModel(args, train_model, epoch):
prefix = "[]_{}".format(train_model._device_prefix, train_model._devices[0])
predictor_export_meta = pred_exp.PredictorExportMeta(
predict_net=train_model.net.Proto(),
parameters=data_parallel_model.GetCheckpointParams(train_model),
inputs=[prefix + "/data"],
outputs=[prefix + "/softmax"],
shapes={
prefix + "/softmax": (1, args.num_labels),
prefix + "/data": (args.num_channels, args.image_size, args.image_size)
}
)
# save the train_model for the current epoch
model_path = "%s/%s_%d.mdl" % (
args.file_store_path,
args.save_model_name,
epoch,
)
# set db_type to be "minidb" instead of "log_file_db", which breaks
# the serialization in save_to_db. Need to switch back to log_file_db
# after migration
pred_exp.save_to_db(
db_type="minidb",
db_destination=model_path,
predictor_export_meta=predictor_export_meta,
)
def SaveModel(args, train_model, epoch, use_ideep):
prefix = "[]_{}".format(train_model._device_prefix,
train_model._devices[0])
predictor_export_meta = pred_exp.PredictorExportMeta(
predict_net=train_model.net.Proto(),
parameters=data_parallel_model.GetCheckpointParams(train_model),
inputs=[prefix + "/data"],
outputs=[prefix + "/softmax"],
shapes={
prefix + "/softmax": (1, args.num_labels),
prefix + "/data":
(args.num_channels, args.image_size, args.image_size)
})
# save the train_model for the current epoch
model_path = "%s/%s_%d.mdl" % (
args.file_store_path,
args.save_model_name,
epoch,
)
# set db_type to be "minidb" instead of "log_file_db", which breaks
# the serialization in save_to_db. Need to switch back to log_file_db
# after migration
pred_exp.save_to_db(db_type="minidb",
db_destination=model_path,
predictor_export_meta=predictor_export_meta,
use_ideep=use_ideep)
def SaveModel(args, train_model, epoch):
prefix = "gpu_{}".format(train_model._devices[0])
predictor_export_meta = pred_exp.PredictorExportMeta(
predict_net=train_model.net.Proto(),
parameters=GetCheckpointParams(train_model),
inputs=[prefix + "/data"],
outputs=[prefix + "/softmax"],
shapes={
prefix + "/softmax": (1, args.num_labels),
prefix + "/data":
(args.num_channels,
args.clip_length_of if args.input_type else args.clip_length_rgb,
args.crop_size, args.crop_size)
})
# save the train_model for the current epoch
model_path = "%s/%s_%d.mdl" % (
args.file_store_path,
args.model_name,
epoch,
)
# save the model
pred_exp.save_to_db(
db_type='minidb',
db_destination=model_path,
predictor_export_meta=predictor_export_meta,
)
def save_pytorch_model_and_load_c2_net(model):
pem, ws = model.get_predictor_export_meta_and_workspace()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path, db_type = os.path.join(tmpdirname, "model"), "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
net = prepare_prediction_net(db_path, db_type)
return net
def test_db_fails_without_params(self):
with self.assertRaises(Exception):
for db_type in ["minidb"]:
db_file = tempfile.NamedTemporaryFile(
delete=False, suffix=".{}".format(db_type))
pe.save_to_db(db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=self.predictor_export_meta)
def save_caffe2_rep_to_db(
caffe2_backend_rep,
output_path,
input_names,
output_names,
num_workers,
):
# netdef external_input includes internally produced blobs
actual_external_inputs = set()
produced = set()
for operator in caffe2_backend_rep.predict_net.op:
for blob in operator.input:
if blob not in produced:
actual_external_inputs.add(blob)
for blob in operator.output:
produced.add(blob)
for blob in output_names:
if blob not in produced:
actual_external_inputs.add(blob)
param_names = [
blob for blob in actual_external_inputs
if blob not in input_names
]
init_net = core.Net(caffe2_backend_rep.init_net)
predict_net = core.Net(caffe2_backend_rep.predict_net)
# predictor_exporter requires disjoint params, inputs and outputs
for i, param in enumerate(param_names):
if param in output_names:
saved_name = param + '_PARAM'
init_net.Copy(param, saved_name)
predict_net.Copy(saved_name, param)
param_names[i] = saved_name
output_shapes = {}
for blob in output_names:
output_shapes[blob] = (0,)
# Required because of https://github.com/pytorch/pytorch/pull/6456/files
with caffe2_backend_rep.workspace._ctx:
workspace.RunNetOnce(init_net)
predictor_export_meta = predictor_exporter.PredictorExportMeta(
predict_net=predict_net,
parameters=param_names,
inputs=input_names,
outputs=output_names,
shapes=output_shapes,
net_type='dag',
num_workers=num_workers,
)
predictor_exporter.save_to_db(
db_type='minidb',
db_destination=output_path,
predictor_export_meta=predictor_export_meta,
)
logger.info('Caffe2 predictor net saved as: {}'.format(output_path))
def test_db_fails_without_params(self):
with self.assertRaises(Exception):
for db_type in ["minidb"]:
db_file = tempfile.NamedTemporaryFile(
delete=False, suffix=".{}".format(db_type))
pe.save_to_db(
db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=self.predictor_export_meta)
def save(self, db_path, db_type):
""" Saves network to db
:param db_path see save_to_db
:param db_type see save_to_db
"""
previous_workspace = workspace.CurrentWorkspace()
workspace.SwitchWorkspace(self._workspace_id)
meta = self.get_predictor_export_meta()
for parameter in self._parameters:
if np.any(np.isnan(workspace.FetchBlob(parameter))):
logger.info("WARNING: parameter {} is nan".format(parameter))
save_to_db(db_type, db_path, meta)
workspace.SwitchWorkspace(previous_workspace)
def save(self, db_path, db_type):
""" Saves network to db
:param db_path see save_to_db
:param db_type see save_to_db
"""
meta = self.get_predictor_export_meta()
for parameter in self._parameters:
parameter_data = workspace.FetchBlob(parameter)
if parameter_data.dtype.kind in {"U", "S", "O"}:
continue # Don't bother checking string blobs for nan
if np.any(np.isnan(parameter_data)):
logger.info("WARNING: parameter {} is nan".format(parameter))
save_to_db(db_type, db_path, meta)
def save(self, db_path, db_type):
""" Saves network to db
:param db_path see save_to_db
:param db_type see save_to_db
"""
meta = self.get_predictor_export_meta()
for parameter in self._parameters:
parameter_data = workspace.FetchBlob(parameter)
if parameter_data.dtype.kind in {"U", "S", "O"}:
continue # Don't bother checking string blobs for nan
if np.any(np.isnan(parameter_data)):
logger.info("WARNING: parameter {} is nan".format(parameter))
save_to_db(db_type, db_path, meta)
def _dummy_model_copy(self, model_name, path):
net = core.Net(model_name)
C2.set_net(net)
inp = 'Input'
output = 'Output'
workspace.FeedBlob(inp, np.array([1.0]))
workspace.FeedBlob(output, np.array([1.0]))
net.Copy([inp], [output])
meta = PredictorExportMeta(
net,
[],
[inp],
[output],
)
save_to_db('minidb', path, meta)
def save_sum_deterministic_policy(model_names, path, db_type):
net = core.Net("DeterministicPolicy")
C2.set_net(net)
output = "ActionProbabilities"
workspace.FeedBlob(output, np.array([1.0]))
model_outputs = []
for model in model_names:
model_output = "{}_Output".format(model)
workspace.FeedBlob(model_output, np.array([[1.0]], dtype=np.float32))
model_outputs.append(model_output)
max_action = C2.FlattenToVec(C2.ArgMax(C2.Transpose(C2.Sum(*model_outputs))))
one_blob = C2.NextBlob("one")
workspace.FeedBlob(one_blob, np.array([1.0], dtype=np.float32))
C2.net().SparseToDense([max_action, one_blob, model_outputs[0]], [output])
meta = PredictorExportMeta(net, [one_blob], model_outputs, [output])
save_to_db(db_type, path, meta)
def check_save_load(
self,
model,
expected_num_params,
expected_num_inputs,
expected_num_outputs,
check_equality=True,
):
pem, ws = model.get_predictor_export_meta_and_workspace()
self.assertEqual(expected_num_params, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(expected_num_inputs, len(pem.inputs))
self.assertEqual(expected_num_outputs, len(pem.outputs))
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: ", db_path)
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
input_tensors = _flatten_named_tuple(input_prototype)
input_names = model.input_blob_names()
self.assertEqual(len(input_tensors), len(input_names))
for name, tensor in zip(input_names, input_tensors):
workspace.FeedBlob(name, tensor.numpy())
workspace.RunNet(net)
output_arrays = [
workspace.FetchBlob(b) for b in model.output_blob_names()
]
output = model(input_prototype)
output_tensors = _flatten_named_tuple(output)
self.assertEqual(len(output_arrays), len(output_tensors))
if check_equality:
for a, t in zip(output_arrays, output_tensors):
# FXIME: PyTorch and Caffe2 has slightly different operator implementation;
# assert_array_equal would fail in some cases :(
npt.assert_allclose(t.detach().numpy(), a, atol=1e-6)
def export_nets_to_predictor_file(c2_prepared,
input_names,
output_names,
predictor_path,
extra_params=None):
# netdef external_input includes internally produced blobs
actual_external_inputs = set()
produced = set()
for operator in c2_prepared.predict_net.op:
for blob in operator.input:
if blob not in produced:
actual_external_inputs.add(blob)
for blob in operator.output:
produced.add(blob)
for blob in output_names:
if blob not in produced:
actual_external_inputs.add(blob)
param_names = [
blob for blob in actual_external_inputs
if blob not in input_names and blob not in output_names
]
if extra_params is not None:
param_names += extra_params
init_net = core.Net(c2_prepared.init_net)
predict_net = core.Net(c2_prepared.predict_net)
# Required because of https://github.com/pytorch/pytorch/pull/6456/files
with c2_prepared.workspace._ctx:
workspace.RunNetOnce(init_net)
predictor_export_meta = pe.PredictorExportMeta(
predict_net=predict_net,
parameters=param_names,
inputs=input_names,
outputs=output_names,
shapes={x: ()
for x in input_names + output_names},
net_type="simple",
)
pe.save_to_db(
db_type=CAFFE2_DB_TYPE,
db_destination=predictor_path,
predictor_export_meta=predictor_export_meta,
)
def save(self, db_path, db_type):
""" Saves network to db
:param db_path see save_to_db
:param db_type see save_to_db
"""
previous_workspace = workspace.CurrentWorkspace()
workspace.SwitchWorkspace(self._workspace_id)
meta = self.get_predictor_export_meta()
for parameter in self._parameters:
parameter_data = workspace.FetchBlob(parameter)
logger.info("DATA TYPE " + parameter_data.dtype.kind)
if parameter_data.dtype.kind in {'U', 'S', 'O'}:
continue # Don't bother checking string blobs for nan
logger.info("Checking parameter {} for nan".format(parameter))
if np.any(np.isnan(parameter_data)):
logger.info("WARNING: parameter {} is nan".format(parameter))
save_to_db(db_type, db_path, meta)
workspace.SwitchWorkspace(previous_workspace)
def check_save_load(
self, model, expected_num_params, expected_num_inputs, expected_num_outputs
):
pem, ws = model.get_predictor_export_meta_and_workspace()
self.assertEqual(expected_num_params, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(expected_num_inputs, len(pem.inputs))
self.assertEqual(expected_num_outputs, len(pem.outputs))
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: ", db_path)
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
input_tensors = _flatten_named_tuple(input_prototype)
input_names = model.input_blob_names()
self.assertEqual(len(input_tensors), len(input_names))
for name, tensor in zip(input_names, input_tensors):
workspace.FeedBlob(name, tensor.numpy())
workspace.RunNet(net)
output_arrays = [workspace.FetchBlob(b) for b in model.output_blob_names()]
output = model(input_prototype)
output_tensors = _flatten_named_tuple(output)
self.assertEqual(len(output_arrays), len(output_tensors))
for a, t in zip(output_arrays, output_tensors):
# FXIME: PyTorch and Caffe2 has slightly different operator implementation;
# assert_array_equal would fail in some cases :(
npt.assert_allclose(t.detach().numpy(), a, atol=1e-6)
def SaveModel(train_model, save_dir, epoch):
predictor_export_meta = pred_exp.PredictorExportMeta(
predict_net=train_model.net.Proto(),
parameters=GetCheckpointParams(train_model),
inputs=['data_uint8'],
outputs=['softmax'],
shapes={
'data': {1, 9600},
'softmax': {1, 40}
})
model_path = '%s/%s_%d.mdl' % (
save_dir,
train_model.net.Proto().name,
epoch,
)
pred_exp.save_to_db(
db_type='minidb',
db_destination=model_path,
predictor_export_meta=predictor_export_meta,
)
def test_get_predictor_export_meta_and_workspace(self):
model = Model()
pem, ws = model.get_predictor_export_meta_and_workspace()
self.assertEqual(3, len(pem.parameters)) # 2 params + 1 const
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(2, len(pem.inputs))
self.assertEqual(4, len(pem.outputs))
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: ", db_path)
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
state_features = input_prototype.state.float_features.numpy()
action_features = input_prototype.action.float_features.numpy()
workspace.FeedBlob("state:float_features", state_features)
workspace.FeedBlob("action:float_features", action_features)
workspace.RunNet(net)
net_sum = workspace.FetchBlob("sum")
net_mul = workspace.FetchBlob("mul")
net_plus_one = workspace.FetchBlob("plus_one")
net_linear = workspace.FetchBlob("linear")
model_sum, model_mul, model_plus_one, model_linear = model(
input_prototype)
npt.assert_array_equal(model_sum.numpy(), net_sum)
npt.assert_array_equal(model_mul.numpy(), net_mul)
npt.assert_array_equal(model_plus_one.numpy(), net_plus_one)
npt.assert_array_equal(model_linear.detach().numpy(), net_linear)
def test_load_device_scope(self):
for param, value in self.params.items():
workspace.FeedBlob(param, value)
pem = pe.PredictorExportMeta(
predict_net=self.predictor_export_meta.predict_net,
parameters=self.predictor_export_meta.parameters,
inputs=self.predictor_export_meta.inputs,
outputs=self.predictor_export_meta.outputs,
shapes=self.predictor_export_meta.shapes,
net_type='dag',
)
db_type = 'minidb'
db_file = tempfile.NamedTemporaryFile(delete=False,
suffix=".{}".format(db_type))
pe.save_to_db(db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=pem)
workspace.ResetWorkspace()
with core.DeviceScope(core.DeviceOption(caffe2_pb2.CPU, 1)):
meta_net_def = pe.load_from_db(
db_type=db_type,
filename=db_file.name,
)
init_net = core.Net(
pred_utils.GetNet(meta_net_def, pc.GLOBAL_INIT_NET_TYPE))
predict_init_net = core.Net(
pred_utils.GetNet(meta_net_def, pc.PREDICT_INIT_NET_TYPE))
# check device options
for op in list(init_net.Proto().op) + list(
predict_init_net.Proto().op):
self.assertEqual(1, op.device_option.device_id)
self.assertEqual(caffe2_pb2.CPU, op.device_option.device_type)
def test_load_device_scope(self):
for param, value in self.params.items():
workspace.FeedBlob(param, value)
pem = pe.PredictorExportMeta(
predict_net=self.predictor_export_meta.predict_net,
parameters=self.predictor_export_meta.parameters,
inputs=self.predictor_export_meta.inputs,
outputs=self.predictor_export_meta.outputs,
shapes=self.predictor_export_meta.shapes,
net_type='dag',
)
db_type = 'minidb'
db_file = tempfile.NamedTemporaryFile(
delete=False, suffix=".{}".format(db_type))
pe.save_to_db(
db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=pem)
workspace.ResetWorkspace()
with core.DeviceScope(core.DeviceOption(caffe2_pb2.CPU, 1)):
meta_net_def = pe.load_from_db(
db_type=db_type,
filename=db_file.name,
)
init_net = core.Net(pred_utils.GetNet(meta_net_def,
pc.GLOBAL_INIT_NET_TYPE))
predict_init_net = core.Net(pred_utils.GetNet(
meta_net_def, pc.PREDICT_INIT_NET_TYPE))
# check device options
for op in list(init_net.Proto().op) + list(predict_init_net.Proto().op):
self.assertEqual(1, op.device_option.cuda_gpu_id)
self.assertEqual(caffe2_pb2.CPU, op.device_option.device_type)
def test_meta_net_def_net_runs(self):
for param, value in viewitems(self.params):
workspace.FeedBlob(param, value)
extra_init_net = core.Net('extra_init')
extra_init_net.ConstantFill('data', 'data', value=1.0)
pem = pe.PredictorExportMeta(
predict_net=self.predictor_export_meta.predict_net,
parameters=self.predictor_export_meta.parameters,
inputs=self.predictor_export_meta.inputs,
outputs=self.predictor_export_meta.outputs,
shapes=self.predictor_export_meta.shapes,
extra_init_net=extra_init_net,
net_type='dag',
)
db_type = 'minidb'
db_file = tempfile.NamedTemporaryFile(delete=False,
suffix=".{}".format(db_type))
pe.save_to_db(db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=pem)
workspace.ResetWorkspace()
meta_net_def = pe.load_from_db(
db_type=db_type,
filename=db_file.name,
)
self.assertTrue("data" not in workspace.Blobs())
self.assertTrue("y" not in workspace.Blobs())
init_net = pred_utils.GetNet(meta_net_def, pc.PREDICT_INIT_NET_TYPE)
# 0-fills externalblobs blobs and runs extra_init_net
workspace.RunNetOnce(init_net)
self.assertTrue("data" in workspace.Blobs())
self.assertTrue("y" in workspace.Blobs())
print(workspace.FetchBlob("data"))
np.testing.assert_array_equal(workspace.FetchBlob("data"),
np.ones(shape=(1, 5)))
np.testing.assert_array_equal(workspace.FetchBlob("y"),
np.zeros(shape=(1, 10)))
# Load parameters from DB
global_init_net = pred_utils.GetNet(meta_net_def,
pc.GLOBAL_INIT_NET_TYPE)
workspace.RunNetOnce(global_init_net)
# Run the net with a reshaped input and verify we are
# producing good numbers (with our custom implementation)
workspace.FeedBlob("data", np.random.randn(2, 5).astype(np.float32))
predict_net = pred_utils.GetNet(meta_net_def, pc.PREDICT_NET_TYPE)
self.assertEqual(predict_net.type, 'dag')
workspace.RunNetOnce(predict_net)
np.testing.assert_array_almost_equal(
workspace.FetchBlob("y"),
workspace.FetchBlob("data").dot(self.params["y_w"].T) +
self.params["y_b"])
def save(self, db_path, db_type):
# The workspace here is expected to be the Workspace class from ONNX
with self.ws._ctx:
save_to_db(db_type, db_path, self.pem)
def test_get_predictor_export_meta_and_workspace_with_feature_extractor(
self):
model = Model()
state_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS)
for i in range(1, 5)
}
action_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS)
for i in range(5, 9)
}
extractor = PredictorFeatureExtractor(
state_normalization_parameters=state_normalization_parameters,
action_normalization_parameters=action_normalization_parameters,
normalize=False,
)
pem, ws = model.get_predictor_export_meta_and_workspace(
feature_extractor=extractor)
# model has 2 params + 1 const. extractor has 1 const.
self.assertEqual(4, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(3, len(pem.inputs))
self.assertEqual(4, len(pem.outputs))
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: ", db_path)
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
state_features = input_prototype.state.float_features
action_features = input_prototype.action.float_features
float_features_values = (torch.cat(
(state_features, action_features), dim=1).reshape(-1).numpy())
float_features_keys = np.arange(1, 9)
float_features_lengths = np.array([8], dtype=np.int32)
workspace.FeedBlob("input/float_features.keys",
float_features_keys)
workspace.FeedBlob("input/float_features.values",
float_features_values)
workspace.FeedBlob("input/float_features.lengths",
float_features_lengths)
workspace.RunNet(net)
net_sum = workspace.FetchBlob("sum")
net_mul = workspace.FetchBlob("mul")
net_plus_one = workspace.FetchBlob("plus_one")
net_linear = workspace.FetchBlob("linear")
model_sum, model_mul, model_plus_one, model_linear = model(
input_prototype)
npt.assert_array_equal(model_sum.numpy(), net_sum)
npt.assert_array_equal(model_mul.numpy(), net_mul)
npt.assert_array_equal(model_plus_one.numpy(), net_plus_one)
npt.assert_allclose(model_linear.detach().numpy(),
net_linear,
rtol=1e-4)
def test_get_predictor_export_meta_and_workspace_full(self):
model = Model()
state_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS)
for i in range(1, 5)
}
action_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS)
for i in range(5, 9)
}
extractor = PredictorFeatureExtractor(
state_normalization_parameters=state_normalization_parameters,
action_normalization_parameters=action_normalization_parameters,
normalize=False,
)
output_transformer = TestOutputTransformer()
pem, ws = model.get_predictor_export_meta_and_workspace(
feature_extractor=extractor, output_transformer=output_transformer)
# model has 2 params + 1 const. extractor has 1 const. output_transformer has 1 const.
self.assertEqual(5, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(3, len(pem.inputs))
self.assertEqual(5, len(pem.outputs))
self.assertEqual(
{
"output/string_weighted_multi_categorical_features.lengths",
"output/string_weighted_multi_categorical_features.keys",
"output/string_weighted_multi_categorical_features.values.lengths",
"output/string_weighted_multi_categorical_features.values.keys",
"output/string_weighted_multi_categorical_features.values.values",
},
set(pem.outputs),
)
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: {}".format(db_path))
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
state_features = input_prototype.state.float_features
action_features = input_prototype.action.float_features
float_features_values = (torch.cat(
(state_features, action_features), dim=1).reshape(-1).numpy())
float_features_keys = np.arange(1, 9)
float_features_lengths = np.array([8], dtype=np.int32)
workspace.FeedBlob("input/float_features.keys",
float_features_keys)
workspace.FeedBlob("input/float_features.values",
float_features_values)
workspace.FeedBlob("input/float_features.lengths",
float_features_lengths)
workspace.RunNet(net)
model_sum, model_mul, model_plus_one, model_linear = model(
input_prototype)
lengths = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.lengths")
keys = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.keys")
values_lengths = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.lengths"
)
values_keys = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.keys"
)
values_values = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.values"
)
N = 1
npt.assert_array_equal(np.ones(N, dtype=np.int32), lengths)
npt.assert_array_equal(np.zeros(N, dtype=np.int64), keys)
npt.assert_array_equal([1] * N, values_lengths)
npt.assert_array_equal(np.array([b"TestAction"], dtype=np.object),
values_keys)
npt.assert_array_equal(model_linear.detach().numpy().reshape(-1),
values_values)
# Let's save the deploy model with the trained weights and biases to a file.
# In[18]:
# construct the model to be exported
# the inputs/outputs of the model are manually specified.
pe_meta = pe.PredictorExportMeta(
predict_net=deploy_model.net.Proto(),
parameters=[str(b) for b in deploy_model.params],
inputs=["data"],
outputs=["softmax"],
)
# save the model to a file. Use minidb as the file format
pe.save_to_db("minidb", os.path.join(root_folder, "mnist_model.minidb"), pe_meta)
print("The deploy model is saved to: " + root_folder + "/mnist_model.minidb")
# Now we can load the model back and run the prediction to verify it works.
# In[19]:
# we retrieve the last input data out and use it in our prediction test before we scratch the workspace
blob = workspace.FetchBlob("data")
pyplot.figure()
_ = visualize.NCHW.ShowMultiple(blob)
# reset the workspace, to make sure the model is actually loaded
workspace.ResetWorkspace(root_folder)
def save(self, db_path, db_type):
# The workspace here is expected to be the Workspace class from ONNX
with self.ws._ctx:
save_to_db(db_type, db_path, self.pem)
def test_get_predictor_export_meta_and_workspace_with_feature_extractor(self):
model = Model()
state_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS) for i in range(1, 5)
}
action_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS) for i in range(5, 9)
}
extractor = PredictorFeatureExtractor(
state_normalization_parameters=state_normalization_parameters,
action_normalization_parameters=action_normalization_parameters,
normalize=False,
)
pem, ws = model.get_predictor_export_meta_and_workspace(
feature_extractor=extractor
)
# model has 2 params + 1 const. extractor has 1 const.
self.assertEqual(4, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(3, len(pem.inputs))
self.assertEqual(4, len(pem.outputs))
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: ", db_path)
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
state_features = input_prototype.state.float_features
action_features = input_prototype.action.float_features
float_features_values = (
torch.cat((state_features, action_features), dim=1).reshape(-1).numpy()
)
float_features_keys = np.arange(1, 9)
float_features_lengths = np.array([8], dtype=np.int32)
workspace.FeedBlob("input/float_features.keys", float_features_keys)
workspace.FeedBlob("input/float_features.values", float_features_values)
workspace.FeedBlob("input/float_features.lengths", float_features_lengths)
workspace.RunNet(net)
net_sum = workspace.FetchBlob("sum")
net_mul = workspace.FetchBlob("mul")
net_plus_one = workspace.FetchBlob("plus_one")
net_linear = workspace.FetchBlob("linear")
model_sum, model_mul, model_plus_one, model_linear = model(input_prototype)
npt.assert_array_equal(model_sum.numpy(), net_sum)
npt.assert_array_equal(model_mul.numpy(), net_mul)
npt.assert_array_equal(model_plus_one.numpy(), net_plus_one)
npt.assert_allclose(model_linear.detach().numpy(), net_linear, rtol=1e-4)
test_accuracy = np.zeros(100)
for i in range(100):
# Run a forward pass of the net on the current batch
workspace.RunNet(test_model.net)
# Collect the batch accuracy from the workspace
test_accuracy[i] = workspace.FetchBlob('accuracy')
pe_meta = pe.PredictorExportMeta(
predict_net=deploy_model.net.Proto(),
parameters=[str(b) for b in deploy_model.params],
inputs=["data"],
outputs=["softmax"],
)
# save the model to a file. Use minidb as the file format
pe.save_to_db("minidb", os.path.join(sys.argv[2], "mnist_model.minidb"),
pe_meta)
print("Deploy model saved to: " + sys.argv[2] + "/mnist_model.minidb")
# Grab and display the last data batch used before we scratch the workspace. This purely for our convenience...
blob = workspace.FetchBlob("data")
# reset the workspace, to make sure the model is actually loaded
workspace.ResetWorkspace(sys.argv[2])
# verify that all blobs from training are destroyed.
print("The blobs in the workspace after reset: {}".format(workspace.Blobs()))
# load the predict net
predict_net = pe.prepare_prediction_net(
os.path.join(sys.argv[2], "mnist_model.minidb"), "minidb")
def test_get_predictor_export_meta_and_workspace_full(self):
model = Model()
state_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS) for i in range(1, 5)
}
action_normalization_parameters = {
i: NormalizationParameters(feature_type=CONTINUOUS) for i in range(5, 9)
}
extractor = PredictorFeatureExtractor(
state_normalization_parameters=state_normalization_parameters,
action_normalization_parameters=action_normalization_parameters,
normalize=False,
)
output_transformer = TestOutputTransformer()
pem, ws = model.get_predictor_export_meta_and_workspace(
feature_extractor=extractor, output_transformer=output_transformer
)
# model has 2 params + 1 const. extractor has 1 const. output_transformer has 1 const.
self.assertEqual(5, len(pem.parameters))
for p in pem.parameters:
self.assertTrue(ws.HasBlob(p))
self.assertEqual(3, len(pem.inputs))
self.assertEqual(5, len(pem.outputs))
self.assertEqual(
{
"output/string_weighted_multi_categorical_features.lengths",
"output/string_weighted_multi_categorical_features.keys",
"output/string_weighted_multi_categorical_features.values.lengths",
"output/string_weighted_multi_categorical_features.values.keys",
"output/string_weighted_multi_categorical_features.values.values",
},
set(pem.outputs),
)
input_prototype = model.input_prototype()
with tempfile.TemporaryDirectory() as tmpdirname:
db_path = os.path.join(tmpdirname, "model")
logger.info("DB path: {}".format(db_path))
db_type = "minidb"
with ws._ctx:
save_to_db(db_type, db_path, pem)
# Load the model from DB file and run it
net = prepare_prediction_net(db_path, db_type)
state_features = input_prototype.state.float_features
action_features = input_prototype.action.float_features
float_features_values = (
torch.cat((state_features, action_features), dim=1).reshape(-1).numpy()
)
float_features_keys = np.arange(1, 9)
float_features_lengths = np.array([8], dtype=np.int32)
workspace.FeedBlob("input/float_features.keys", float_features_keys)
workspace.FeedBlob("input/float_features.values", float_features_values)
workspace.FeedBlob("input/float_features.lengths", float_features_lengths)
workspace.RunNet(net)
model_sum, model_mul, model_plus_one, model_linear = model(input_prototype)
lengths = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.lengths"
)
keys = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.keys"
)
values_lengths = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.lengths"
)
values_keys = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.keys"
)
values_values = workspace.FetchBlob(
"output/string_weighted_multi_categorical_features.values.values"
)
N = 1
npt.assert_array_equal(np.ones(N, dtype=np.int32), lengths)
npt.assert_array_equal(np.zeros(N, dtype=np.int64), keys)
npt.assert_array_equal([1] * N, values_lengths)
npt.assert_array_equal(
np.array([b"TestAction"], dtype=np.object), values_keys
)
npt.assert_array_equal(
model_linear.detach().numpy().reshape(-1), values_values
)
pyplot.figure()
softmax = workspace.FetchBlob('softmax')
_ = pyplot.plot(softmax[0], 'ro')
pyplot.title('Prediction for the first image')
pyplot.figure()
softmax = workspace.FetchBlob('softmax')
_ = pyplot.plot(softmax[1], 'ro')
pyplot.title('Prediction for the second image')
pyplot.figure()
softmax = workspace.FetchBlob('softmax')
_ = pyplot.plot(softmax[2], 'ro')
pyplot.title('Prediction for the third image')
pyplot.show()
#GUARDAR MODELO EN UN FICHERO
'''
# construct the model to be exported
# the inputs/outputs of the model are manually specified.
pe_meta = pe.PredictorExportMeta(
predict_net=deploy_model.net.Proto(),
parameters=[str(b) for b in deploy_model.params],
inputs=["data"],
outputs=["softmax"],
)
# save the model to a file. Use minidb as the file format
pe.save_to_db("minidb", os.path.join(root_folder, "mnist_model.minidb"), pe_meta)
print("The deploy model is saved to: " + root_folder + "/mnist_model.minidb")
'''
#Coger el modelo
if i % 25 == 0:
print("Iter: {}, loss: {}, accuracy: {}".format(
i, loss[i], accuracy[i]))
plt.plot(loss, 'b')
plt.plot(accuracy, 'r')
plt.title("Summary of Training Run")
plt.xlabel("Iteration")
plt.legend(("Loss", "Accuracy"), loc="upper right")
plt.show()
pe_meta = pe.PredictorExportMeta(
predict_net=deploy_model.net.Proto(),
parameters=[str(b) for b in deploy_model.params],
inputs=["data"],
outputs=["softmax"],
)
pe.save_to_db("minidb", os.path.join(root_folder, "mnist_model.minidb"),
pe_meta)
print("Deploy model saved to:" + root_folder + "/mnist_model.minidb")
blob = workspace.FetchBlob("data")
plt.figure()
plt.title("Batch of Testing Data")
_ = visualize.NCHW.ShowMultiple(blob)
workspace.ResetWorkspace(root_folder)
print("The blobs in the workspace after reset: {}".format(workspace.Blobs()))
predict_net = pe.prepare_prediction_net(
os.path.join(root_folder, "mnist_model.minidb"), "minidb")
print("The blobs in the workspace after loading the model: {}".format(
workspace.Blobs()))
workspace.FeedBlob("data", blob)
workspace.RunNetOnce(predict_net)
def test_meta_net_def_net_runs(self):
for param, value in viewitems(self.params):
workspace.FeedBlob(param, value)
extra_init_net = core.Net('extra_init')
extra_init_net.ConstantFill('data', 'data', value=1.0)
pem = pe.PredictorExportMeta(
predict_net=self.predictor_export_meta.predict_net,
parameters=self.predictor_export_meta.parameters,
inputs=self.predictor_export_meta.inputs,
outputs=self.predictor_export_meta.outputs,
shapes=self.predictor_export_meta.shapes,
extra_init_net=extra_init_net,
net_type='dag',
)
db_type = 'minidb'
db_file = tempfile.NamedTemporaryFile(
delete=False, suffix=".{}".format(db_type))
pe.save_to_db(
db_type=db_type,
db_destination=db_file.name,
predictor_export_meta=pem)
workspace.ResetWorkspace()
meta_net_def = pe.load_from_db(
db_type=db_type,
filename=db_file.name,
)
self.assertTrue("data" not in workspace.Blobs())
self.assertTrue("y" not in workspace.Blobs())
init_net = pred_utils.GetNet(meta_net_def, pc.PREDICT_INIT_NET_TYPE)
# 0-fills externalblobs blobs and runs extra_init_net
workspace.RunNetOnce(init_net)
self.assertTrue("data" in workspace.Blobs())
self.assertTrue("y" in workspace.Blobs())
print(workspace.FetchBlob("data"))
np.testing.assert_array_equal(
workspace.FetchBlob("data"), np.ones(shape=(1, 5)))
np.testing.assert_array_equal(
workspace.FetchBlob("y"), np.zeros(shape=(1, 10)))
# Load parameters from DB
global_init_net = pred_utils.GetNet(meta_net_def,
pc.GLOBAL_INIT_NET_TYPE)
workspace.RunNetOnce(global_init_net)
# Run the net with a reshaped input and verify we are
# producing good numbers (with our custom implementation)
workspace.FeedBlob("data", np.random.randn(2, 5).astype(np.float32))
predict_net = pred_utils.GetNet(meta_net_def, pc.PREDICT_NET_TYPE)
self.assertEqual(predict_net.type, 'dag')
workspace.RunNetOnce(predict_net)
np.testing.assert_array_almost_equal(
workspace.FetchBlob("y"),
workspace.FetchBlob("data").dot(self.params["y_w"].T) +
self.params["y_b"])