def onnx2keras(onnx_model_path, input_names, output_dir, swap_channel_ordering=True): from onnx2keras import onnx_to_keras onnx_model = onnx.load(onnx_model_path) k_model = onnx_to_keras(onnx_model, input_names, change_ordering=swap_channel_ordering, name_policy='renumerate') weights = k_model.get_weights() K.set_learning_phase(0) with K.get_session() as sess: init = tf.global_variables_initializer() sess.run(init) k_model.set_weights(weights) tf.saved_model.simple_save( sess, output_dir, inputs={ input.name: tensor for input, tensor in zip(onnx_model.graph.input, k_model.inputs) }, outputs={ output.name: tensor for output, tensor in zip(onnx_model.graph.output, k_model.outputs) })
def convertToKerasAndBack(fileName, outputFileName, inputs): ret = None onnxModel = onnx.load(fileName) kwArgs = dict() if "shuffle" in fileName: kwArgs["input_shapes"] = [1, 3, 224, 224] import shufflenet import keras kerasModel = shufflenet.ShuffleNet(groups=3) kerasModel.load_weights( "keras-shufflenet/weights/ShuffleNet_1X_g3_br_0.25_373.hdf5") kerasModel.compile(optimizer=keras.optimizers.SGD(lr=.05, decay=5e-4, momentum=0.9), metrics=['accuracy'], loss='categorical_crossentropy') ret = kerasModel.predict(inputs[0][0].transpose(0, 2, 3, 1)) else: kerasModel = onnx_to_keras(onnxModel, getOnnxInputNames(fileName), verbose=False, **kwArgs) #tf.keras.utils.plot_model(kerasModel, show_shapes=True) backconvOnnxModel = onnxmltools.convert_keras(kerasModel) onnxmltools.utils.save_model(backconvOnnxModel, outputFileName) return ret
def onnx2keras_pb(onnx_model_path, input_names, output_names, output_path, swap_channel_ordering=True): from onnx2keras import onnx_to_keras from convert.utils import freeze_session output_dir, filename = os.path.split(output_path) onnx_model = onnx.load(onnx_model_path) k_model = onnx_to_keras(onnx_model, input_names, change_ordering=swap_channel_ordering, name_policy='renumerate') weights = k_model.get_weights() K.set_learning_phase(0) with K.get_session() as sess: init = tf.global_variables_initializer() sess.run(init) k_model.set_weights(weights) frozen_graph = freeze_session(sess, keep_var_names=None, output_names=output_names) tf.train.write_graph(frozen_graph, output_dir, filename, as_text=False)
def pytorch2savedmodel(onnx_model_path, saved_model_dir): onnx_model = onnx.load(onnx_model_path) input_names = ['input_ids', "attention_mask", "token_type_ids", "task_id"] k_model = onnx_to_keras(onnx_model=onnx_model, input_names=input_names, change_ordering=True, verbose=False) weights = k_model.get_weights() K.set_learning_phase(0) saved_model_dir = Path(saved_model_dir) if saved_model_dir.exists(): shutil.rmtree(str(saved_model_dir)) saved_model_dir.mkdir() with K.get_session() as sess: init = tf.global_variables_initializer() sess.run(init) k_model.set_weights(weights) tf.saved_model.simple_save( sess, str(saved_model_dir.joinpath('1')), inputs={'image_array': k_model.input}, outputs=dict((output.name, tensor) for output, tensor in zip( onnx_model.graph.output, k_model.outputs)))
def pytorch2savedmodel(onnx_model_path, saved_model_dir): onnx_model = onnx.load(onnx_model_path) input_names = ["image_array"] k_model = onnx_to_keras( onnx_model=onnx_model, input_names=input_names, change_ordering=True, verbose=False, ) weights = k_model.get_weights() K.set_learning_phase(0) saved_model_dir = Path(saved_model_dir) if saved_model_dir.exists(): shutil.rmtree(str(saved_model_dir)) saved_model_dir.mkdir() tf.saved_model.save( k_model, str(saved_model_dir.joinpath("1")), )
def get_keras(dynamic_input=False): onnx_model = onnx.load( "/home/fico/DeepL/Gans/Mobile_Cyclegan/vangogh2photo_fixed.onnx") # Call the converter (input - is the main model input name, can be different for your model) k_model = onnx_to_keras(onnx_model, ['input'], test_c_order=True, dynamic_input=dynamic_input) # if dynamic_input == True: # model_config = k_model.get_config() # print(model_config['layers'][0]) print(k_model.summary()) return k_model
def input_processing_onnx(file_path=None): ''' Process input from onnx file. Parameters: ----------- file_path: path to onnx input file. (still in developed) Return ----------- number_of_layer: Number of layers in the neural network number_of_neurons_each_layer: list of number of neurons in each layer weight: list of weights of the neurons network bias: list of bias at each layer ../sample_input/eranmnist_benchmark/onnx/tf/mnist_relu_3_50.onnx ''' onnx_model = onnx.load(file_path) onnx_model.graph.node[2].output = 'dense/Relu_0' print(onnx_model.graph.node[2].output) # print(onnx_model.graph.input) exit(0) kera_model = onnx_to_keras(onnx_model, input_names=['dense_input']) number_of_layer = 0 number_of_neurons_each_layer = [] weight = [] bias = [] for layer in kera_model.layers: layer_weight = layer.get_weights() if not layer_weight: continue number_of_layer += 1 if number_of_layer == 1: number_of_neurons_each_layer.append( np.array(layer_weight[0]).shape[0]) number_of_neurons_each_layer.append(np.array(layer_weight[0]).shape[1]) weight.append(np.array(layer_weight[0])) bias.append(np.array(layer_weight[1])) number_of_layer += 1 print(number_of_layer) print(number_of_neurons_each_layer) print(weight) print(bias) return number_of_layer, number_of_neurons_each_layer, weight, bias
def ToKeras(self, output_name, path=None, genotype=None, init_channels=None, layers=None): model = self.load_model(path, genotype, init_channels, layers) model.eval() input_np = np.random.uniform(0, 1, (1, 3, 32, 32)) input_var = torch.FloatTensor(input_np) output = model(input_var) torch.onnx.export(model, (input_var), output_name + ".onnx", verbose=True, input_names=['input'], output_names=['output']) import onnx from onnx2keras import onnx_to_keras onnx_model = onnx.load(output_name + ".onnx") k_model = onnx_to_keras(onnx_model, ['input']) k_model.save(output_name + ".h5")
def driver(inputdir, outputdir, datadir, plotdir, preddir, trainflag, validflag, testflag, normalize, fmean, fstdev, scale, fmin, fmax, scalelims, fsize, rmse_file, r2_file, inD, outD, ilog, olog, TFRfile, batch_size, ncores, buffer_size, gridsearch, architectures, layers, lay_params, activations, act_params, nodes, lengthscale, max_lr, clr_mode, clr_steps, epochs, patience, weight_file, resume, plot_cases, fxvals, xlabel, ylabel, filters=None, filtconv=1.): """ Driver function to handle model training and evaluation. Inputs ------ inputdir : string. Path/to/directory of inputs. outputdir : string. Path/to/directory of outputs. datadir : string. Path/to/directory of data. plotdir : string. Path/to/directory of plots. preddir : string. Path/to/directory of predictions. trainflag : bool. Determines whether to train the NN model. validflag : bool. Determines whether to validate the NN model. testflag : bool. Determines whether to test the NN model. normalize : bool. Determines whether to normalize the data. fmean : string. Path/to/file of mean of training data. fstdev : string. Path/to/file of stdev of training data. scale : bool. Determines whether to scale the data. fmin : string. Path/to/file of minima of training data. fmax : string. Path/to/file of maxima of training data. scalelims : list, floats. [min, max] of range of scaled data. rmse_file : string. Prefix for savefiles for RMSE calculations. r2_file : string. Prefix for savefiles for R2 calculations. inD : int. Dimensionality of the input data. outD : int. Dimensionality of the output data. ilog : bool. Determines whether to take the log10 of intput data. olog : bool. Determines whether to take the log10 of output data. TFRfile : string. Prefix for TFRecords files. batch_size : int. Size of batches for training/validating/testing. ncores : int. Number of cores to use to load data cases. buffer_size: int. Number of data cases to pre-load in memory. gridsearch : bool. Determines whether to perform a grid search over `architectures`. architectures: list. Model architectures to consider. layers : list, str. Types of hidden layers. lay_params : list, ints. Parameters for the layer type E.g., kernel size activations: list, str. Activation functions for each hidden layer. act_params : list, floats. Parameters for the activation functions. nodes : list, ints. For layers with nodes, number of nodes per layer. lengthscale: float. Minimum learning rat.e max_lr : float. Maximum learning rate. clr_mode : string. Sets the cyclical learning rate function. clr_steps : int. Number of steps per cycle of the learning rate. epochs : int. Max number of iterations through dataset for training. patience : int. If no model improvement after `patience` epochs, halts training. weight_file: string. Path/to/file where NN weights are saved. resume : bool. Determines whether to resume training. plot_cases : list, ints. Cases from test set to plot. fxvals : string. Path/to/file of X-axis values to correspond to predicted Y values. xlabel : string. X-axis label for plotting. ylabel : string. Y-axis label for plotting. filters : list, strings. Paths/to/filter files. Default: None If specified, will compute RMSE/R2 stats over the integrated filter bandpasses. filtconv : float. Conversion factor for filter file x-axis values to desired unit. Default: 1.0 """ # Get file names, calculate number of cases per file print('Loading files & calculating total number of batches...') try: datsize = np.load(inputdir + fsize) num_train = datsize[0] num_valid = datsize[1] num_test = datsize[2] except: ftrain = glob.glob(datadir + 'train' + os.sep + '*.npy') fvalid = glob.glob(datadir + 'valid' + os.sep + '*.npy') ftest = glob.glob(datadir + 'test' + os.sep + '*.npy') num_train = U.data_set_size(ftrain, ncores) num_valid = U.data_set_size(fvalid, ncores) num_test = U.data_set_size(ftest, ncores) np.save(inputdir + fsize, np.array([num_train, num_valid, num_test], dtype=int)) del ftrain, fvalid, ftest print("Data set sizes") print("Training data:", num_train) print("Validation data:", num_valid) print("Testing data:", num_test) print("Total data:", num_train + num_valid + num_test) train_batches = num_train // batch_size valid_batches = num_valid // batch_size test_batches = num_test // batch_size # Update `clr_steps` if clr_steps == "range test": clr_steps = train_batches * epochs rng_test = True else: clr_steps = train_batches * int(clr_steps) rng_test = False # Get mean/stdev for normalizing if normalize: print('\nNormalizing the data...') try: mean = np.load(inputdir + fmean) stdev = np.load(inputdir + fstdev) except: print("Calculating the mean and standard deviation of the data " +\ "using Welford's method.") # Compute stats ftrain = glob.glob(datadir + 'train' + os.sep + '*.npy') mean, stdev, datmin, datmax = S.mean_stdev(ftrain, inD, ilog, olog) np.save(inputdir + fmean, mean) np.save(inputdir + fstdev, stdev) np.save(inputdir + fmin, datmin) np.save(inputdir + fmax, datmax) del datmin, datmax, ftrain print("mean :", mean) print("stdev:", stdev) # Slice desired indices x_mean, y_mean = mean[:inD], mean[inD:] x_std, y_std = stdev[:inD], stdev[inD:] # Memory cleanup -- no longer need full mean/stdev arrays del mean, stdev else: x_mean = 0. x_std = 1. y_mean = 0. y_std = 1. if olog: # To properly calculate RMSE & R2 for log-scaled output try: y_mean_delog = np.load(inputdir + fmean.replace(".npy", "_delog.npy")) except: ftrain = glob.glob(datadir + 'train' + os.sep + '*.npy') mean_delog = S.mean_stdev(ftrain, inD, ilog, False)[0] del ftrain y_mean_delog = mean_delog[inD:] np.save(inputdir + fmean.replace(".npy", "_delog.npy"), y_mean_delog) else: y_mean_delog = y_mean # Get min/max values for scaling if scale: print('\nScaling the data...') try: datmin = np.load(inputdir + fmin) datmax = np.load(inputdir + fmax) except: ftrain = glob.glob(datadir + 'train' + os.sep + '*.npy') mean, stdev, datmin, datmax = S.mean_stdev(ftrain, inD, ilog, olog) np.save(inputdir + fmean, mean) np.save(inputdir + fstdev, stdev) np.save(inputdir + fmin, datmin) np.save(inputdir + fmax, datmax) del mean, stdev, ftrain print("min :", datmin) print("max :", datmax) # Slice desired indices x_min, y_min = datmin[:inD], datmin[inD:] x_max, y_max = datmax[:inD], datmax[inD:] # Memory cleanup -- no longer need min/max arrays del datmin, datmax # Normalize min/max values if normalize: x_min = U.normalize(x_min, x_mean, x_std) x_max = U.normalize(x_max, x_mean, x_std) y_min = U.normalize(y_min, y_mean, y_std) y_max = U.normalize(y_max, y_mean, y_std) else: x_min = 0. x_max = 1. y_min = 0. y_max = 1. scalelims = [0., 1.] # Get TFRecord file names print('\nLoading TFRecords file names...') TFRpath = inputdir + 'TFRecords' + os.sep + TFRfile ftrain_TFR = glob.glob(TFRpath + 'train*.tfrecords') fvalid_TFR = glob.glob(TFRpath + 'valid*.tfrecords') ftest_TFR = glob.glob(TFRpath + 'test*.tfrecords') if len(ftrain_TFR) == 0 or len(fvalid_TFR) == 0 or len(ftest_TFR) == 0: # Doesn't exist -- make them print("\nSome TFRecords files do not exist yet.") ftrain = glob.glob(datadir + 'train' + os.sep + '*.npy') fvalid = glob.glob(datadir + 'valid' + os.sep + '*.npy') ftest = glob.glob(datadir + 'test' + os.sep + '*.npy') if len(ftrain_TFR) == 0: print("Making TFRecords for training data...") U.make_TFRecord( inputdir + 'TFRecords' + os.sep + TFRfile + 'train.tfrecords', ftrain, inD, ilog, olog, batch_size, train_batches) if len(fvalid_TFR) == 0: print("\nMaking TFRecords for validation data...") U.make_TFRecord( inputdir + 'TFRecords' + os.sep + TFRfile + 'valid.tfrecords', fvalid, inD, ilog, olog, batch_size, valid_batches) if len(ftest_TFR) == 0: print("\nMaking TFRecords for test data...") U.make_TFRecord( inputdir + 'TFRecords' + os.sep + TFRfile + 'test.tfrecords', ftest, inD, ilog, olog, batch_size, test_batches) print("\nTFRecords creation complete.") # Free memory del ftrain, fvalid, ftest # Get TFR file names for real this time ftrain_TFR = glob.glob(TFRpath + 'train*.tfrecords') fvalid_TFR = glob.glob(TFRpath + 'valid*.tfrecords') ftest_TFR = glob.glob(TFRpath + 'test*.tfrecords') # Load the xvals if fxvals is not None: xvals = np.load(fxvals) else: xvals = None # Perform grid search if gridsearch: # Train a model for each architecture, w/ unique directories print("\nPerforming a grid search.\n") maxlen = 0 for i, arch in enumerate(architectures): if len(arch) > maxlen: maxlen = len(arch) archdir = os.path.join(outputdir, arch, '') wsplit = weight_file.rsplit(os.sep, 1)[1].rsplit('.', 1) wfile = ''.join([archdir, wsplit[0], '_', arch, '.', wsplit[1]]) U.make_dir(archdir) nn = NNModel(ftrain_TFR, fvalid_TFR, ftest_TFR, inD, outD, olog, x_mean, x_std, y_mean, y_std, x_min, x_max, y_min, y_max, scalelims, ncores, buffer_size, batch_size, [train_batches, valid_batches, test_batches], layers[i], lay_params[i], activations[i], act_params[i], nodes[i], lengthscale, max_lr, clr_mode, clr_steps, wfile, stop_file='./STOP', resume=resume, train_flag=True, shuffle=True) nn.train(train_batches, valid_batches, epochs, patience) P.loss(nn, archdir) # Print/save out the minmium validation loss for each architecture minvl = np.ones(len(architectures)) * np.inf print('Grid search summary') print('-------------------') with open(outputdir + 'gridsearch.txt', 'w') as foo: foo.write('Grid search summary\n') foo.write('-------------------\n') for i, arch in enumerate(architectures): archdir = os.path.join(outputdir, arch, '') history = np.load(archdir + 'history.npz') minvl[i] = np.amin(history['val_loss']) print(arch.ljust(maxlen, ' ') + ': ' + str(minvl[i])) with open(outputdir + 'gridsearch.txt', 'a') as foo: foo.write(arch.ljust(maxlen, ' ') + ': ' \ + str(minvl[i]) + '\n') return # Train a model if trainflag: print('\nBeginning model training.\n') nn = NNModel(ftrain_TFR, fvalid_TFR, ftest_TFR, inD, outD, olog, x_mean, x_std, y_mean, y_std, x_min, x_max, y_min, y_max, scalelims, ncores, buffer_size, batch_size, [train_batches, valid_batches, test_batches], layers, lay_params, activations, act_params, nodes, lengthscale, max_lr, clr_mode, clr_steps, weight_file, stop_file='./STOP', train_flag=True, shuffle=True, resume=resume) nn.train(train_batches, valid_batches, epochs, patience) # Plot the loss P.loss(nn, plotdir) # Call new model with shuffle=False nn = NNModel(ftrain_TFR, fvalid_TFR, ftest_TFR, inD, outD, olog, x_mean, x_std, y_mean, y_std, x_min, x_max, y_min, y_max, scalelims, ncores, buffer_size, batch_size, [train_batches, valid_batches, test_batches], layers, lay_params, activations, act_params, nodes, lengthscale, max_lr, clr_mode, clr_steps, weight_file, stop_file='./STOP', train_flag=False, shuffle=False, resume=False) if '.h5' in weight_file or '.hdf5' in weight_file: nn.model.load_weights(weight_file) # Load the model # Save in ONNX format try: onnx_model = keras2onnx.convert_keras(nn.model) onnx.save_model(onnx_model, nn.weight_file.rsplit('.', 1)[0] + '.onnx') except Exception as e: print("Unable to convert the Keras model to ONNX:") print(e) else: nn.model = onnx_to_keras(onnx.load_model(weight_file), ['input_1']) # Validate model if (validflag or trainflag) and not rng_test: print('\nValidating the model...\n') # Y values print(' Predicting...') fvalpred = nn.Yeval('pred', 'valid', preddir, denorm=(normalize == False and scale == False)) fvalpred = glob.glob(fvalpred + '*') print(' Loading the true Y values...') fvaltrue = nn.Yeval('true', 'valid', preddir, denorm=(normalize == False and scale == False)) fvaltrue = glob.glob(fvaltrue + '*') ### RMSE & R2 print('\n Calculating RMSE & R2...') if not normalize and not scale: val_stats = S.rmse_r2(fvalpred, fvaltrue, y_mean, olog=olog, y_mean_delog=y_mean_delog, x_vals=xvals, filters=filters, filtconv=filtconv) else: val_stats = S.rmse_r2(fvalpred, fvaltrue, y_mean, y_std, y_min, y_max, scalelims, olog, y_mean_delog, xvals, filters, filtconv) # RMSE if np.any(val_stats[0] != -1) and np.any(val_stats[1] != -1): print(' Normalized RMSE : ', val_stats[0]) print(' Mean normalized RMSE : ', np.mean(val_stats[0])) print(' Denormalized RMSE : ', val_stats[1]) print(' Mean denormalized RMSE: ', np.mean(val_stats[1])) np.savez(outputdir + rmse_file + '_val_norm.npz', rmse=val_stats[0], rmse_mean=np.mean(val_stats[0])) saveRMSEnorm = True saveRMSEdenorm = True elif np.any(val_stats[0] != -1): print(' RMSE : ', val_stats[0]) print(' Mean RMSE: ', np.mean(val_stats[0])) saveRMSEnorm = True saveRMSEdenorm = False elif np.any(val_stats[1] != -1): print(' RMSE : ', val_stats[1]) print(' Mean RMSE: ', np.mean(val_stats[1])) saveRMSEnorm = False saveRMSEdenorm = True else: print(" No files passed in to compute RMSE.") saveRMSEnorm = False saveRMSEdenorm = False if saveRMSEnorm: P.plot(''.join([plotdir, rmse_file, '_val_norm.png']), xvals, val_stats[0], xlabel, 'RMSE') np.savez(outputdir + rmse_file + '_val_norm.npz', rmse=val_stats[0], rmse_mean=np.mean(val_stats[0])) if saveRMSEdenorm: P.plot(''.join([plotdir, rmse_file, '_val_denorm.png']), xvals, val_stats[1], xlabel, 'RMSE') np.savez(outputdir + rmse_file + '_val_denorm.npz', rmse=val_stats[1], rmse_mean=np.mean(val_stats[1])) # R2 if np.any(val_stats[2] != -1) and np.any(val_stats[3] != -1): print(' Normalized R2 : ', val_stats[2]) print(' Mean normalized R2 : ', np.mean(val_stats[2])) print(' Denormalized R2 : ', val_stats[3]) print(' Mean denormalized R2: ', np.mean(val_stats[3])) saveR2norm = True saveR2denorm = True elif np.any(val_stats[2] != -1): print(' R2 : ', val_stats[2]) print(' Mean R2: ', np.mean(val_stats[2])) saveR2norm = True saveR2denorm = False elif np.any(val_stats[3] != -1): print(' R2 : ', val_stats[3]) print(' Mean R2: ', np.mean(val_stats[3])) saveR2norm = False saveR2denorm = True else: print(" No files passed in to compute R2.") saveR2norm = False saveR2denorm = False if saveR2norm: P.plot(''.join([plotdir, r2_file, '_val_norm.png']), xvals, val_stats[2], xlabel, '$R^2$') np.savez(outputdir + r2_file + '_val_norm.npz', r2=val_stats[2], r2_mean=np.mean(val_stats[2])) if saveR2denorm: P.plot(''.join([plotdir, r2_file, '_val_denorm.png']), xvals, val_stats[3], xlabel, '$R^2$') np.savez(outputdir + r2_file + '_val_denorm.npz', r2=val_stats[3], r2_mean=np.mean(val_stats[3])) # Evaluate model on test set if testflag and not rng_test: print('\nTesting the model...\n') # Y values print(' Predicting...') ftestpred = nn.Yeval('pred', 'test', preddir, denorm=(normalize == False and scale == False)) ftestpred = glob.glob(ftestpred + '*') print(' Loading the true Y values...') ftesttrue = nn.Yeval('true', 'test', preddir, denorm=(normalize == False and scale == False)) ftesttrue = glob.glob(ftesttrue + '*') ### RMSE & R2 print('\n Calculating RMSE & R2...') if not normalize and not scale: test_stats = S.rmse_r2(ftestpred, ftesttrue, y_mean, olog=olog, y_mean_delog=y_mean_delog, x_vals=xvals, filters=filters, filtconv=filtconv) else: test_stats = S.rmse_r2(ftestpred, ftesttrue, y_mean, y_std, y_min, y_max, scalelims, olog, y_mean_delog, xvals, filters, filtconv) # RMSE if np.any(test_stats[0] != -1) and np.any(test_stats[1] != -1): print(' Normalized RMSE : ', test_stats[0]) print(' Mean normalized RMSE : ', np.mean(test_stats[0])) print(' Denormalized RMSE : ', test_stats[1]) print(' Mean denormalized RMSE: ', np.mean(test_stats[1])) np.savez(outputdir + rmse_file + '_val_norm.npz', rmse=test_stats[0], rmse_mean=np.mean(test_stats[0])) saveRMSEnorm = True saveRMSEdenorm = True elif np.any(test_stats[0] != -1): print(' RMSE : ', test_stats[0]) print(' Mean RMSE: ', np.mean(test_stats[0])) saveRMSEnorm = True saveRMSEdenorm = False elif np.any(test_stats[1] != -1): print(' RMSE : ', test_stats[1]) print(' Mean RMSE: ', np.mean(test_stats[1])) saveRMSEnorm = False saveRMSEdenorm = True else: print(" No files passed in to compute RMSE.") saveRMSEnorm = False saveRMSEdenorm = False if saveRMSEnorm: P.plot(''.join([plotdir, rmse_file, '_test_norm.png']), xvals, test_stats[0], xlabel, 'RMSE') np.savez(outputdir + rmse_file + '_test_norm.npz', rmse=test_stats[0], rmse_mean=np.mean(test_stats[0])) if saveRMSEdenorm: P.plot(''.join([plotdir, rmse_file, '_test_denorm.png']), xvals, test_stats[1], xlabel, 'RMSE') np.savez(outputdir + rmse_file + '_test_denorm.npz', rmse=test_stats[1], rmse_mean=np.mean(test_stats[1])) # R2 if np.any(test_stats[2] != -1) and np.any(test_stats[3] != -1): print(' Normalized R2 : ', test_stats[2]) print(' Mean normalized R2 : ', np.mean(test_stats[2])) print(' Denormalized R2 : ', test_stats[3]) print(' Mean denormalized R2: ', np.mean(test_stats[3])) saveR2norm = True saveR2denorm = True elif np.any(test_stats[2] != -1): print(' R2 : ', test_stats[2]) print(' Mean R2: ', np.mean(test_stats[2])) saveR2norm = True saveR2denorm = False elif np.any(test_stats[3] != -1): print(' R2 : ', test_stats[3]) print(' Mean R2: ', np.mean(test_stats[3])) saveR2norm = False saveR2denorm = True else: print(" No files passed in to compute R2.") saveR2norm = False saveR2denorm = False if saveR2norm: P.plot(''.join([plotdir, r2_file, '_test_norm.png']), xvals, test_stats[2], xlabel, '$R^2$') np.savez(outputdir + r2_file + '_test_norm.npz', r2=test_stats[2], r2_mean=np.mean(test_stats[2])) if saveR2denorm: P.plot(''.join([plotdir, r2_file, '_test_denorm.png']), xvals, test_stats[3], xlabel, '$R^2$') np.savez(outputdir + r2_file + '_test_denorm.npz', r2=test_stats[3], r2_mean=np.mean(test_stats[3])) # Plot requested cases if not rng_test: predfoo = sorted(glob.glob(preddir + 'test' + os.sep + 'pred*')) truefoo = sorted(glob.glob(preddir + 'test' + os.sep + 'true*')) if len(predfoo) > 0 and len(truefoo) > 0: print("\nPlotting the requested cases...") nplot = 0 for v in plot_cases: fname = plotdir + 'spec' + str(v) + '_pred-vs-true.png' predspec = np.load(predfoo[v // batch_size])[v % batch_size] predspec = U.denormalize( U.descale(predspec, y_min, y_max, scalelims), y_mean, y_std) truespec = np.load(truefoo[v // batch_size])[v % batch_size] truespec = U.denormalize( U.descale(truespec, y_min, y_max, scalelims), y_mean, y_std) if olog: predspec[olog] = 10**predspec[olog] truespec[olog] = 10**truespec[olog] P.plot_spec(fname, predspec, truespec, xvals, xlabel, ylabel) nplot += 1 print(" Plot " + str(nplot) + "/" + str(len(plot_cases)), end='\r') print("") else: raise Exception("No predictions found in " + preddir + "test.") return
model = LayerTest(kernel_size=kernel_size, padding=padding, stride=stride) model.eval() input_np = np.random.uniform(0, 1, (1, 3, 224, 224)) input_var = Variable(torch.FloatTensor(input_np)) torch.onnx.export(model, input_var, "_tmpnet.onnx", verbose=True, input_names=['test_in'], output_names=['test_out']) onnx_model = onnx.load('_tmpnet.onnx') k_model = onnx_to_keras(onnx_model, ['test_in'], change_ordering=change_ordering) error = check_torch_keras_error( model, k_model, input_np, change_ordering=change_ordering) print('Error:', error) if max_error < error: max_error = error print('Max error: {0}'.format(max_error))
### sudo pip3 install onnx2keras tf-nightly ### tf-nightly-2.2.0-dev20200502 import onnx from onnx2keras import onnx_to_keras import tensorflow as tf import shutil onnx_model = onnx.load('human-pose-estimation-3d-0001.onnx') k_model = onnx_to_keras(onnx_model=onnx_model, input_names=['data'], change_ordering=True) shutil.rmtree('saved_model', ignore_errors=True) tf.saved_model.save(k_model, 'saved_model') """ $ saved_model_cli show --dir saved_model --all MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs: signature_def['__saved_model_init_op']: The given SavedModel SignatureDef contains the following input(s): The given SavedModel SignatureDef contains the following output(s): outputs['__saved_model_init_op'] tensor_info: dtype: DT_INVALID shape: unknown_rank name: NoOp Method name is: signature_def['serving_default']: The given SavedModel SignatureDef contains the following input(s):
FHardtanhTest, LayerReLUTest, FReLUTest, LayerELUTest, FPELUTest, ]: for i in range(10): model = act_type() model.eval() input_np = np.random.uniform(0, 1, (1, 3, 224, 224)) input_var = torch.FloatTensor(input_np) torch.onnx.export(model, input_var, "_tmpnet.onnx", verbose=True, input_names=['test_in'], output_names=['test_out']) onnx_model = onnx.load('_tmpnet.onnx') k_model = onnx_to_keras(onnx_model, ['test_in']) os.unlink('_tmpnet.onnx') error = check_torch_keras_error(model, k_model, input_np) print('Error:', error) if max_error < error: max_error = error print('Max error: {0}'.format(max_error))
import numpy as np import cv2 import onnx import onnxmltools import onnx2keras from onnx2keras import onnx_to_keras # convert to keras onnx_path = './base-model-new-320.onnx' keras_path = onnx_path.split('/')[-1].split('.')[0] onnx_model = onnxmltools.utils.load_model(onnx_path) keras_model = onnx_to_keras(onnx_model, ['input']) keras_model.save(keras_path) keras_model.summary()
def load(path, filename): """Load network from file. Parameters ---------- path: str Path to directory where to load model from. filename: str Name of file to load model from. Returns ------- : dict[str, Union[keras.models.Sequential, function]] A dictionary of objects that constitute the input model. It must contain the following two keys: - 'model': keras.models.Sequential Keras model instance of the network. - 'val_fn': function Function that allows evaluating the original model. """ filepath = str(os.path.join(path, filename)) # Load the Pytorch model. mod = import_script(path, filename) kwargs = mod.kwargs if hasattr(mod, 'kwargs') else {} model_pytorch = mod.Model(**kwargs) map_location = 'cpu' if not torch.cuda.is_available() else None for ext in ['.pth', '.pkl']: model_path = filepath + ext if os.path.exists(model_path): break assert model_path, "Pytorch state_dict not found at {}".format(model_path) model_pytorch.load_state_dict( torch.load(model_path, map_location=map_location)) # Switch from train to eval mode to ensure Dropout / BatchNorm is handled # correctly. model_pytorch.eval() # Run on dummy input with correct shape to trace the Pytorch model. input_shape = [1] + list(model_pytorch.input_shape) input_numpy = np.random.random_sample(input_shape).astype(np.float32) input_torch = torch.from_numpy(input_numpy).float() output_torch = model_pytorch(input_torch) output_numpy = to_numpy(output_torch) # Export as onnx model, and then reload. input_names = ['input_0'] output_names = ['output_{}'.format(i) for i in range(len(output_torch))] dynamic_axes = {'input_0': {0: 'batch_size'}} dynamic_axes.update({name: {0: 'batch_size'} for name in output_names}) torch.onnx.export(model_pytorch, input_torch, filepath + '.onnx', input_names=input_names, output_names=output_names, dynamic_axes=dynamic_axes) model_onnx = onnx.load(filepath + '.onnx') # onnx.checker.check_model(model_onnx) # Crashes with segmentation fault. # Compute ONNX Runtime output prediction. ort_session = onnxruntime.InferenceSession(filepath + '.onnx') input_onnx = {ort_session.get_inputs()[0].name: input_numpy} output_onnx = ort_session.run(None, input_onnx) # Compare ONNX Runtime and PyTorch results. err_msg = "Pytorch model could not be ported to ONNX. Output difference: " np.testing.assert_allclose(output_numpy, output_onnx[0], rtol=1e-03, atol=1e-05, err_msg=err_msg) print("Pytorch model was successfully ported to ONNX.") change_ordering = keras.backend.image_data_format() == 'channels_last' if change_ordering: input_numpy = np.moveaxis(input_numpy, 1, -1) output_numpy = np.moveaxis(output_numpy, 1, -1) # Import this here; import changes image_data_format to channels_first. from onnx2keras import onnx_to_keras # Port ONNX model to Keras. model_keras = onnx_to_keras(model_onnx, input_names, [input_shape[1:]], change_ordering=change_ordering, verbose=False) if change_ordering: keras.backend.set_image_data_format('channels_last') # Save the keras model. keras.models.save_model(model_keras, filepath + '.h5') # Loading the model here is a workaround for version conflicts with # TF > 2.0.1 and keras > 2.2.5. Should be able to remove this later. model_keras = keras.models.load_model(filepath + '.h5') model_keras.compile('sgd', 'categorical_crossentropy', ['accuracy', keras.metrics.top_k_categorical_accuracy]) # Compute Keras output and compare against ONNX. output_keras = model_keras.predict(input_numpy) err_msg = "ONNX model could not be ported to Keras. Output difference: " np.testing.assert_allclose(output_numpy, output_keras, rtol=1e-03, atol=1e-05, err_msg=err_msg) print("ONNX model was successfully ported to Keras.") return {'model': model_keras, 'val_fn': model_keras.evaluate}
import warnings from onnx_tf.backend import prepare import onnx import tensorflow as tf import onnx2keras import numpy as np warnings.filterwarnings('ignore') #sess = ort.InferenceSession('model.onnx') model = onnx.load_model("model.onnx") k_model = onnx2keras.onnx_to_keras(onnx_model=model, input_names=["input_data"], change_ordering=True, verbose=False) print(k_model.layers)
import torch from torch.autograd import Variable from onnx2keras import onnx_to_keras, check_torch_keras_error import onnx from torchvision.models.densenet import densenet121 if __name__ == '__main__': model = densenet121() model.eval() input_np = np.random.uniform(0, 1, (1, 3, 224, 224)) input_var = Variable(torch.FloatTensor(input_np), requires_grad=False) output = model(input_var) torch.onnx.export(model, (input_var), "_tmpnet.onnx", verbose=True, input_names=['test_in1'], output_names=['test_out']) onnx_model = onnx.load('_tmpnet.onnx') k_model = onnx_to_keras(onnx_model, ['test_in1', 'test_in2'], change_ordering=True) error = check_torch_keras_error(model, k_model, input_np, change_ordering=True) print('Max error: {0}'.format(error))
import onnx from onnx2keras import onnx_to_keras import tensorflow as tf # Converts ONNX networks to keras networks # Currently only for the actor network # Load ONNX model onnx_actor = onnx.load('actor.onnx') # Replace incompatible placeholder node from Matlab onnx_actor.graph.node[5].op_type = 'Tanh' print('Loaded and replaced') # Convert model to keras actor_onnx = onnx_to_keras(onnx_actor, ['observation']) # Rebuild model in tensorflow to get the right layers actor_tf = tf.keras.Sequential() actor_tf.add(tf.keras.Input(shape=(26, ))) actor_tf.add(tf.keras.layers.Dense(400)) actor_tf.add(tf.keras.layers.Dense(300, activation='relu')) actor_tf.add(tf.keras.layers.Dense(8)) actor_tf.add(tf.keras.layers.Activation('tanh')) # actor_tf.add(tf.keras.layers.Flatten()) # Apply weights and biases weight_0 = actor_onnx.layers[1].get_weights() actor_tf.layers[0].set_weights( [tf.reshape(weight_0[0], (26, 400)), weight_0[1]]) weight_1 = actor_onnx.layers[3].get_weights() actor_tf.layers[1].set_weights( [tf.reshape(weight_1[0], (400, 300)), weight_1[1]])
import onnx2keras from onnx2keras import onnx_to_keras import keras import onnx path = "C:/Users/msa/Documents/datasets/pretrained architectures/PointPillars/pfe.onnx" onnx_model = onnx.load(path) k_model = onnx_to_keras(onnx_model) print(k_model)
# Versions of tensorflow used ------------------------- print("tf.__version__ is", tf.__version__) print("tf.keras.__version__ is:", tf.keras.__version__) print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU'))) # Versions of tensorflow used ------------------------- # transform the given images -------------------------- PIL_transform = transforms.ToPILImage() tensor_transform = transforms.ToTensor() # transform the given images -------------------------- # Loading the onnx model ------------------------------ onnx_model = onnx.load("Material_Classifier.onnx") k_model = onnx_to_keras(onnx_model, ['imageinput']) keras.models.save_model(k_model, "Material_Classifier.h5", overwrite=True, include_optimizer=True) # Loading the onnx model ------------------------------ # Folder and image size initialization ---------------- IMG_SIZE = 200 CARBON = "CARBON/" FIBERGLASS = "FIBERGLASS/" LABELS = {CARBON: 0, FIBERGLASS: 1} # Folder and image size initialization ---------------- # Counts and training data ---------------------------- training_data = []
return error if __name__ == '__main__': max_error = 0 for i in range(10): model = FTest() model.eval() input_np1 = np.random.uniform(0, 1, (1, 3, 224, 224)) input_np2 = np.random.uniform(0, 1, (1, 3, 224, 224)) input_var1 = Variable(torch.FloatTensor(input_np1)) input_var2 = Variable(torch.FloatTensor(input_np2)) output = model(input_var1, input_var2) torch.onnx.export(model, (input_var1, input_var2), "_tmpnet.onnx", verbose=True, input_names=['test_in1', 'test_in2'], output_names=['test_out']) onnx_model = onnx.load('_tmpnet.onnx') k_model = onnx_to_keras(onnx_model, ['test_in1', 'test_in2']) error = check_error(output, k_model, [input_np1, input_np2]) if max_error < error: max_error = error print('Max error: {0}'.format(max_error))
input_names=["input"], output_names=["output"], dynamic_axes={ "input": { 0: "batch_size" }, "output": { 0: "batch_size" } }) onnx_model = onnx.load("./temp.onnx") onnx.checker.check_model(onnx_model) inpt = ['input'] keras_model = onnx_to_keras(onnx_model=onnx_model, input_names=inpt, change_ordering=True, verbose=False) converter = tf.lite.TFLiteConverter.from_keras_model(keras_model) converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE] tflite_model = converter.convert() open('modelzoo/model_' + str(i) + '.tflite', "wb").write(tflite_model) data = '' for itr in netEmbedding: for itr2 in itr: data = data + str(itr2) + ',' data = data[:-1] data = data + '\n' file.write(data) file.close()
# print('==> Resuming from checkpoint..') # assert os.path.isfile(resume), 'Error: no checkpoint directory found!' # checkpoint = os.path.dirname(resume) # checkpoint = torch.load(resume) # model.load_state_dict(checkpoint['state_dict']) # dummy_input = Variable(torch.randn(1, 3, 32, 32)) # nchw # # dummy_output = model.module(dummy_input) # # print(dummy_output) # onnx_filename = "model.onnx" # torch.onnx.export(model.module, dummy_input, onnx_filename, output_names=['test_output']) model_onnx = onnx.load('./model.onnx') k_model = onnx_to_keras(model_onnx, input_names=['0']) # Export model as .pb file # tf_rep.export_graph('model_tf.h5') # def load_pb(path_to_pb): # with tf.gfile.GFile(path_to_pb, 'rb') as f: # graph_def = tf.GraphDef() # graph_def.ParseFromString(f.read()) # with tf.Graph().as_default() as graph: # tf.import_graph_def(graph_def, name='') # return graph # tf_graph = load_pb('model_tf.pb') # sess = tf.Session(graph=tf_graph)
!pip install onnx !git clone https://github.com/nerox8664/onnx2keras.git ''' #%cd onnx2keras import tensorflow as tf import onnx from onnx2keras import onnx_to_keras from tensorflow.keras.models import load_model # Load ONNX model onnx_model = onnx.load('/content/pnet_video.onnx') # Call the converter and save keras model k_model = onnx_to_keras(onnx_model, ['input.1'],change_ordering=True) k_model.save('/content/pnet_video.h5') from tensorflow.keras.models import Model from tensorflow.keras.models import load_model from tensorflow.keras.layers import Activation, Lambda, Reshape # Load keras model k_model=load_model('/content/pnet_video.h5') k_model.summary() # Remove edge branch from output edge_model=Model(inputs=k_model.input,outputs=k_model.layers[-2].output) edge_model.summary() # Add softmax on output
args = parser.parse_args() print('Loading data...') (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=args.vocab_size, maxlen=args.max_len) print(len(x_train), 'train sequences') print(len(x_test), 'test sequences') print('Pad sequences (samples x time)') x_train = sequence.pad_sequences(x_train, maxlen=args.max_len) x_test = sequence.pad_sequences(x_test, maxlen=args.max_len) print('x_train shape:', x_train.shape) print('x_test shape:', x_test.shape) print('Load ONNX model...') onnx_model = onnx.load(args.model_path) #onnx.checker.check_model(onnx_model) print('Convert ONNX to Keras...') k_model = onnx_to_keras(onnx_model, ['embedding_input']) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) loss, acc = model.evaluate(x_test, y_test, batch_size=args.batch_size) print("Evaluation result: Loss:", loss, " Accuracy:", acc)
def pytorch_to_keras(model, args, input_shapes=None, change_ordering=False, verbose=False, name_policy=None, use_optimizer=False, do_constant_folding=False): """ By given PyTorch model convert layers with ONNX. Args: model: pytorch model args: pytorch model arguments input_shapes: keras input shapes (using for each InputLayer) change_ordering: change CHW to HWC verbose: verbose output name_policy: use short names, use random-suffix or keep original names for keras layers Returns: model: created keras model. """ logger = logging.getLogger('pytorch2keras') if verbose: logging.basicConfig(level=logging.DEBUG) logger.info('Converter is called.') if name_policy: logger.warning('Name policy isn\'t supported now.') if input_shapes: logger.warning('Custom shapes isn\'t supported now.') if input_shapes and not isinstance(input_shapes, list): input_shapes = [input_shapes] if not isinstance(args, list): args = [args] args = tuple(args) dummy_output = model(*args) if isinstance(dummy_output, torch.autograd.Variable): dummy_output = [dummy_output] input_names = ['input_{0}'.format(i) for i in range(len(args))] output_names = ['output_{0}'.format(i) for i in range(len(dummy_output))] logger.debug('Input_names:') logger.debug(input_names) logger.debug('Output_names:') logger.debug(output_names) stream = io.BytesIO() torch.onnx.export(model, args, stream, do_constant_folding=do_constant_folding, verbose=verbose, input_names=input_names, output_names=output_names) stream.seek(0) onnx_model = onnx.load(stream) if use_optimizer: if use_optimizer is True: optimizer2run = optimizer.get_available_passes() else: use_optimizer = set(use_optimizer) optimizer2run = [ x for x in optimizer.get_available_passes() if x in use_optimizer ] logger.info("Running optimizer:\n%s", "\n".join(optimizer2run)) onnx_model = optimizer.optimize(onnx_model, optimizer2run) k_model = onnx_to_keras(onnx_model=onnx_model, input_names=input_names, input_shapes=input_shapes, name_policy=name_policy, verbose=verbose, change_ordering=change_ordering) return k_model
### tensorflow-gpu==2.2.0 ### onnx==1.7.0 ### onnx2keras==0.0.21 ### https://github.com/amir-abdi/keras_to_tensorflow.git import onnx from onnx2keras import onnx_to_keras import tensorflow as tf import shutil from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2 onnx_model = onnx.load('dbface.onnx') k_model = onnx_to_keras(onnx_model=onnx_model, input_names=['x']) shutil.rmtree('saved_model', ignore_errors=True) tf.saved_model.save(k_model, 'saved_model') # Convert Keras model to ConcreteFunction full_model = tf.function(lambda x: k_model(x)) full_model = full_model.get_concrete_function( tf.TensorSpec(k_model.inputs[0].shape, k_model.inputs[0].dtype)) # Get frozen ConcreteFunction frozen_func = convert_variables_to_constants_v2(full_model) frozen_func.graph.as_graph_def() tf.io.write_graph(graph_or_graph_def=frozen_func.graph, logdir=".", name="dbface.pb", as_text=False)