# `mobile\_exporter <https://github.com/caffe2/caffe2/blob/master/caffe2/python/predictor/mobile_exporter.py>`__ # to generate the two model protobufs that can run on mobile. The first is # used to initialize the network with the correct weights, and the second # actual runs executes the model. We will continue to use the small # super-resolution model for the rest of this tutorial. # # extract the workspace and the model proto from the internal representation c2_workspace = prepared_backend.workspace c2_model = prepared_backend.predict_net # Now import the caffe2 mobile exporter from caffe2.python.predictor import mobile_exporter # call the Export to get the predict_net, init_net. These nets are needed for running things on mobile init_net, predict_net = mobile_exporter.Export(c2_workspace, c2_model, c2_model.external_input) # Let's also save the init_net and predict_net to a file that we will later use for running them on mobile with open('init_net.pb', "wb") as fopen: fopen.write(init_net.SerializeToString()) with open('predict_net.pb', "wb") as fopen: fopen.write(predict_net.SerializeToString()) ###################################################################### # ``init_net`` has the model parameters and the model input embedded in it # and ``predict_net`` will be used to guide the ``init_net`` execution at # run-time. In this tutorial, we will use the ``init_net`` and # ``predict_net`` generated above and run them in both normal Caffe2 # backend and mobile and verify that the output high-resolution cat image # produced in both runs is the same.
# 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") workspace.RunNetOnce(deploy_model.param_init_net) init_net, predict_net = mobile_exporter.Export(workspace, deploy_model.net, deploy_model.params) with open("init_net.pb", "wb") as f: f.write(init_net.SerializeToString()) with open("predict_net.pb", "wb") as f: f.write(predict_net.SerializeToString()) with open("predict_net.pbtxt", "wb") as f: f.write(str(deploy_model.net.Proto())) # Now we can load the model back and run the prediction to verify it works. # we retrieve the last input data out and use it in our prediction test # before we scratch the workspace blob = workspace.FetchBlob("data") # reset the workspace, to make sure the model is actually loaded workspace.ResetWorkspace(root_folder)
print(onnx.helper.printable_graph(model.graph)) import caffe2.python.onnx.backend as backend import numpy as np rep = backend.prepare(model, device="CUDA:0") # or "CPU" #rep = backend.prepare(model, device="CPU") # For the Caffe2 backend: # rep.predict_net is the Caffe2 protobuf for the network # rep.workspace is the Caffe2 workspace for the network # (see the class caffe2.python.onnx.backend.Workspace) outputs = rep.run( np.random.randn(1, Global.img_chn, Global.img_h, Global.img_w).astype(np.float32)) # To run networks with more than one input, pass a tuple # rather than a single numpy ndarray. print(outputs[0]) c2_workspace = rep.workspace c2_graph = rep.predict_net from caffe2.python.predictor import mobile_exporter init_net, predict_net = mobile_exporter.Export(c2_workspace, c2_graph, c2_graph.external_input) with io.open(Global.initnet, 'wb') as f: f.write(init_net.SerializeToString()) with open(Global.prednet, 'wb') as f: f.write(predict_net.SerializeToString())
def main(args): # User defined keyword arguments kwargs = {"order": "NCHW"} kwargs.update(dict(args.kwargs)) model = ModelHelper(name=args.benchmark_name) op_type = args.operator # assumes a brew type op name input_name = args.input_name output_name = args.output_name iters = int(args.iters) for i in range(iters): input_blob_name = input_name + (str(i) if i > 0 and args.chain else '') output_blob_name = output_name + str(i + 1) add_op = getattr(brew, op_type) add_op(model, input_blob_name, output_blob_name, **kwargs) if args.chain: input_name, output_name = output_name, input_name workspace.RunNetOnce(model.param_init_net) extra_init_net_ops = [] def make_blob_on_context(blob_name, blob_data, context): if context.upper() != "CPU": blob_name_modified = "{}_CPU".format(blob_name) else: # CPU case is simple blob_name_modified = blob_name fill_op = core.CreateOperator( "GivenTensorFill", [], [blob_name_modified], arg=[ utils.MakeArgument("shape", blob_data.shape), utils.MakeArgument("values", blob_data) ]) extra_init_net_ops.append(fill_op) # We need to create CPU blobs and add some copy operations in # the init_net if context.upper() == "OPENGL": copy_op = core.CreateOperator("CopyToOpenGL", [blob_name_modified], [blob_name]) extra_init_net_ops.append(copy_op) for unparsed_blob in args.blob: name, unparsed_dims = unparsed_blob.split('=') dims = [int(d) for d in unparsed_dims.split(',')] np_input = np.random.rand(*dims).astype(np.float32) make_blob_on_context(name, np_input, args.context) init_net, predict_net = mobile_exporter.Export(workspace, model.net, model.params) init_net.op.extend(extra_init_net_ops) # Handle manual rewrite if args.context.upper() == "OPENGL": old_ops = [op for op in predict_net.op] del predict_net.op[:] for op in old_ops: op.type = 'OpenGL{}'.format(op.type) predict_net.op.extend(old_ops) if args.debug: print("init_net:") for op in init_net.op: print(" ", op.type, op.input, "-->", op.output) print("predict_net:") for op in predict_net.op: print(" ", op.type, op.input, "-->", op.output) with open(args.predict_net, 'wb') as f: f.write(predict_net.SerializeToString()) with open(args.init_net, 'wb') as f: f.write(init_net.SerializeToString())
def test_mobile_exporter_datatypes(self): model = ModelHelper(name="mobile_exporter_test_model") model.Copy("data_int", "out") model.params.append("data_int") model.Copy("data_obj", "out_obj") model.params.append("data_obj") # Create our mobile exportable networks workspace.RunNetOnce(model.param_init_net) np_data_int = np.random.randint(100, size=(1, 1, 28, 28), dtype=np.int32) workspace.FeedBlob("data_int", np_data_int) np_data_obj = np.array(['aa', 'bb']).astype(np.dtype('O')) workspace.FeedBlob("data_obj", np_data_obj) init_net, predict_net = mobile_exporter.Export(workspace, model.net, model.params) workspace.CreateNet(model.net) workspace.RunNet(model.net) ref_out = workspace.FetchBlob("out") ref_out_obj = workspace.FetchBlob("out_obj") # Clear the workspace workspace.ResetWorkspace() # Populate the workspace with data workspace.RunNetOnce(init_net) # Overwrite the old net workspace.CreateNet(predict_net, True) workspace.RunNet(predict_net.name) manual_run_out = workspace.FetchBlob("out") manual_run_out_obj = workspace.FetchBlob("out_obj") np.testing.assert_allclose(ref_out, manual_run_out, atol=1e-10, rtol=1e-10) np.testing.assert_equal(ref_out_obj, manual_run_out_obj) # Clear the workspace workspace.ResetWorkspace() # Predictor interface test (simulates writing to disk) predictor = workspace.Predictor(init_net.SerializeToString(), predict_net.SerializeToString()) # Output is a vector of outputs. predictor_out = predictor.run([]) assert len(predictor_out) == 2 predictor_out_int = predictor_out[1] predictor_out_obj = predictor_out[0] # The order in predictor_out is non-deterministic. Use type of the entry # to figure out what to compare it to. if isinstance(predictor_out[1][0], bytes): predictor_out_int = predictor_out[0] predictor_out_obj = predictor_out[1] np.testing.assert_allclose(ref_out, predictor_out_int, atol=1e-10, rtol=1e-10) np.testing.assert_equal(ref_out_obj, predictor_out_obj)
def main(): root_path = '/home/osboxes/zementis/scalogram/fault_diagnosis' data_path = os.path.join(root_path, 'data') labels_path = os.path.join(data_path, 'labels.txt') labels_to_classes_map = get_labels_to_classes_map(labels_path) fault_types_path = { 'baseLine': os.path.join(data_path, 'raw_signals', 'baseLine'), 'rollingDefect': os.path.join(data_path, 'raw_signals', 'rollingDefect'), 'innerRace': os.path.join(data_path, 'raw_signals', 'innerRace'), 'outerRace': os.path.join(data_path, 'raw_signals', 'outerRace') } sub_signal_len = 400 # The sample rate is 12 kHz and the approximate motor speed is 1797 RPM. Therefore, there are approximately 401 # sample points per revolution (12000 / (1797 / 60)). for fault_type, fault_dir_path in fault_types_path.items(): sub_signals = get_sub_signals(fault_dir_path, sub_signal_len) sub_signal_idx = 0 for sub_signal in sub_signals: sub_signal_idx += 1 scalo = get_scalogram(sub_signal) scaled_scalo = get_scaled_data( scalo) # scales an array to have values between 0.0 and 1.0 img_obj = PIL.Image.fromarray(scaled_scalo) img_f_name = str(sub_signal_idx) + '_' + fault_type + '.tiff' img_obj.save(os.path.join(data_path, img_f_name)) if sub_signal_idx == 50: break # stop after creating 50 images in each class # Create txt files mapping image names to classes img_to_class_paths = create_img_to_class_files(data_path, labels_to_classes_map) # Create lmdb files lmdb_paths = write_lmdb_files(data_path, img_to_class_paths) model_files_path = os.path.join(root_path, 'model_files') if not os.path.isdir(model_files_path): os.makedirs(model_files_path) workspace.ResetWorkspace(model_files_path) unique_timestamp = str( datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) checkpoint_dir = os.path.join(model_files_path, unique_timestamp) os.makedirs(checkpoint_dir) print("Checkpoint output location: ", checkpoint_dir) # Dataset specific params image_width = sub_signal_len image_height = sub_signal_len image_channels = 1 num_classes = 4 init_net_out_fname = 'init_net.pb' predict_net_out_fname = 'predict_net.pb' # Training params n_iters = 600 # total training iterations batch_size = 10 # batch size for training n_val_images = 30 # total number of validation images validation_interval = 50 # validate every <validation_interval> training iterations n_checkpoint_iters = 200 # output checkpoint db every <checkpoint_iters> iterations # TRAINING MODEL train_model = model_helper.ModelHelper(name="train_net") data, label = add_input(train_model, batch_size=batch_size, db=lmdb_paths['train'], db_type='lmdb') softmax = add_cnn_model_1(train_model, data, num_classes, image_height, image_width, image_channels) add_optmzer_lossfunc(train_model, softmax, label) add_check_points(train_model, unique_timestamp, n_checkpoint_iters, db_type="lmdb") # VALIDATION MODEL # Initialize with ModelHelper class without re-initializing params val_model = model_helper.ModelHelper(name="val_net", init_params=False) data, label = add_input(val_model, batch_size=n_val_images, db=lmdb_paths['val'], db_type='lmdb') softmax = add_cnn_model_1(val_model, data, num_classes, image_height, image_width, image_channels) add_accuracy(val_model, softmax, label) # DEPLOY MODEL # Initialize with ModelHelper class without re-initializing params deploy_model = model_helper.ModelHelper(name="deploy_net", init_params=False) # Add model definition, expect input blob called "data" add_cnn_model_1(deploy_model, "data", num_classes, image_height, image_width, image_channels) print("Training, Validation, and Deploy models all defined!") # Initialize and create the training network workspace.RunNetOnce(train_model.param_init_net) workspace.CreateNet(train_model.net, overwrite=True) # Initialize and create validation network workspace.RunNetOnce(val_model.param_init_net) workspace.CreateNet(val_model.net, overwrite=True) # Placeholder to track loss and validation accuracy training_loss = np.zeros(int(math.ceil(n_iters / validation_interval))) val_accuracy = np.zeros(int(math.ceil(n_iters / validation_interval))) val_count = 0 val_iter_list = np.zeros(int(math.ceil(n_iters / validation_interval))) # run the network (forward & backward pass) for i in range(n_iters): workspace.RunNet(train_model.net) # Validate every <validation_interval> training iterations if (i % validation_interval) == 0: print("Training iter: ", i) training_loss[val_count] = workspace.FetchBlob('loss') workspace.RunNet(val_model.net) val_accuracy[val_count] = workspace.FetchBlob('accuracy') print("Loss: ", str(training_loss[val_count])) print("Validation accuracy: ", str(val_accuracy[val_count]) + "\n") val_iter_list[val_count] = i val_count += 1 fig = pyplot.figure() fig.add_subplot(111) pyplot.title("Training Loss and Validation Accuracy") pyplot.plot(val_iter_list, training_loss, 'b') pyplot.plot(val_iter_list, val_accuracy, 'r') pyplot.xlabel("Training iteration") pyplot.legend(('Training Loss', 'Validation Accuracy'), loc='upper right') pyplot.savefig("loss_and_accuracy.png") pyplot.close() # Save trained model workspace.RunNetOnce(deploy_model.param_init_net) workspace.CreateNet(deploy_model.net, overwrite=True) init_net, predict_net = mobile_exporter.Export(workspace, deploy_model.net, deploy_model.params) init_net_out_path = os.path.join(checkpoint_dir, init_net_out_fname) predict_net_out_path = os.path.join(checkpoint_dir, predict_net_out_fname) with open(init_net_out_path, 'wb') as f: f.write(init_net.SerializeToString()) with open(predict_net_out_path, 'wb') as f: f.write(predict_net.SerializeToString()) print("Model saved as " + init_net_out_path + " and " + predict_net_out_path)
data_parallel_model.GetLearningRateBlobNames(train_model)[0]) values = [ e + 1, lr, loss_sum / batch_num, correct / batch_num, test_res['loss'], test_res['accuracy'], time_ep, ] table = tabulate.tabulate([values], columns, tablefmt='simple', floatfmt='8.4f') if e % 25 == 0: table = table.split('\n') table = '\n'.join([table[1]] + table) else: table = table.split('\n')[2] print(table) checkpoint_params = data_parallel_model.GetCheckpointParams(train_model) init_net, _ = mobile_exporter.Export(workspace, deploy_model.net, checkpoint_params) with open("predict_net.pb", 'wb') as f: f.write(deploy_model.net._net.SerializeToString()) with open("init_net.pb", 'wb') as f: f.write(init_net.SerializeToString())