def output_testcase(model, test_x_list, test_y_list, name, eps): print 'Processing %s' % name assert isinstance(test_x_list, list), 'test_x_list must be a list.' assert isinstance(test_y_list, list), 'test_y_list must be a list.' model.compile(loss='mean_squared_error', optimizer='adamax') model.fit(test_x_list, test_y_list, nb_epoch=1, verbose=False) predict_y_list = model.predict(test_x_list) if not isinstance(predict_y_list, list): predict_y_list = [predict_y_list] print model.summary() export_model(model, 'test_%s.model' % name) with open('test_%s.h' % name, 'w') as f: predict_x_list = [test_x[0] for test_x in test_x_list] x_map = tensor_map_init(predict_x_list, ',\n ') y_map = tensor_map_init(predict_y_list, ',\n ') input_layer_names = ', '.join( ["\"%s\"" % layer_name for layer_name in model.input_names]) output_layer_names = ', '.join( ["\"%s\"" % layer_name for layer_name in model.output_names]) f.write(TEST_CASE % (name, name, input_layer_names, output_layer_names, x_map, y_map, name, eps))
def combine_modules(inpdim, numPolicies, modelF): print('Input Dimension: %d' % inpdim) inp = Input((inpdim, )) out = [] for k in range(numPolicies): _, getScore, _ = getRankModel(inpdim) cfname = modelF.replace(".h5", "_%d.h5" % k) # Normalization layers getScore.add(Dense(1, input_shape=(1, ))) getScore.add(Dense(1, input_shape=(1, ))) print('Loading Model %s' % cfname) getScore.load_weights(cfname) cout = getScore(inp) out.append(cout) if numPolicies > 1: ensembleOut = keras.layers.average(out) else: ensembleOut = cout ensemble = Model(inputs=inp, outputs=ensembleOut) finalfname = modelF.replace(".h5", ".h5") jsonfname = finalfname.replace('.h5', '.json') # Kerasify to c++ export_model(ensemble, finalfname) return
def output_testcase(model, test_x, test_y, name, eps): print("Processing %s" % name) model.compile(loss='mean_squared_error', optimizer='adamax') model.fit(test_x, test_y, nb_epoch=1, verbose=False) predict_y = model.predict(test_x).astype('f') print(model.summary()) export_model(model, 'test_%s.model' % name) with open('test_%s.h' % name, 'w') as f: x_shape, x_data = c_array(test_x[0]) y_shape, y_data = c_array(predict_y[0]) f.write(TEST_CASE % (name, name, x_shape, x_data, y_shape, y_data, name, eps))
def output_testcase(model, test_x, test_y, name, eps): print('Processing %s' % name) model.compile(loss='mse', optimizer='adam') model.fit(test_x, test_y, epochs=1, verbose=False) predict_y = model.predict(test_x).astype('f') print(model.summary()) export_model(model, models_path + '/%s.model' % name) with open(src_path + '/%s_test.cpp' % name, 'w') as f: x_shape, x_data = c_array(test_x[0]) y_shape, y_data = c_array(predict_y[0]) f.write(TEST_CASE % (name, x_shape, x_data, y_shape, y_data, name, eps))
def output_testcase(model, test_x, test_y, name, eps): print(f'Processing {name}') model.compile(loss='mse', optimizer='adam') model.fit(test_x, test_y, epochs=1, verbose=False) predict_y = model.predict(test_x).astype('f') print(model.summary()) path = os.path.abspath(f'models/{name}.model') export_model(model, path) with open(f'include/test/{name}.h', 'w') as f: x_shape, x_data = c_array(test_x[0]) y_shape, y_data = c_array(predict_y[0]) f.write(TEST_CASE % dict(name=name, path=path, eps=eps, x_shape=x_shape, x_data=x_data, y_shape=y_shape, y_data=y_data))
def main(): ''' main routine to train and generate keras classifier model ''' # Model Parameters and Paths # NOTE: Uncomment below cell to generate one of the classifier model (hand or pose or face) timesteps = 5 ## POSE - val_acc: 98% epochs = 1000 batch_size = 32 _dropout = 0.1 _activation = 'relu' _optimizer = 'Adam' class_names = ["close_to_camera", "standing", "sitting"] X_vector_dim = 36 # number of features or columns (pose) samples_path = "../../../train_data/pose/pose_samples_raw.txt" labels_path = "../../../train_data/pose/pose_labels_raw.txt" model_path = '../../../train_data/pose/pose.model' json_model_path = '../../../train_data/pose/pose_model.json' model_weights_path = "../../../train_data/pose/pose_model.h5" # ## HAND - val_acc: 97% # epochs = 1000 # batch_size = 32 # _dropout = 0.1 # _activation='relu' # _optimizer='adam' # class_names = ["fist","pinch","wave","victory","stop","thumbsup"] # X_vector_dim = 40 # number of features or columns (hand) # samples_path = "../../../train_data/hand/hand_samples_raw.txt" # labels_path = "../../../train_data/hand/hand_labels_raw.txt" # model_path = '../../../train_data/hand/hand.model' # json_model_path = '../../../train_data/hand/hand_model.json' # model_weights_path = "../../../train_data/hand/hand_model.h5" # # ## FACE - val_acc: 97% # epochs = 1000 # batch_size = 32 # _dropout = 0.1 # _activation='tanh' # _optimizer='Adadelta' # class_names = ["normal","happy","sad","surprise"] # X_vector_dim = 96 # number of features or columns (face) # samples_path = "../../../train_data/face/face_samples_raw.txt" # labels_path = "../../../train_data/face/face_labels_raw.txt" # model_path = '../../../train_data/face/face.model' # json_model_path = '../../../train_data/face/face_model.json' # model_weights_path = "../../../train_data/face/face_model.h5" # Load Keypoints Samples and Labels X = np.loadtxt(samples_path, dtype="float") y = np.loadtxt(labels_path) y_one_hot = convert_y_to_one_hot(y) # convert to one_hot_encoding vector y_vector_dim = y_one_hot.shape[1] # number of features or columns X_vectors_per_sample = timesteps # number of vectors per sample # Keras LSTM model require 3-Dimensional Tensors. Convert samples to 3D tensors X_3D = samples_to_3D_array(X_vector_dim, X_vectors_per_sample, X) # Perform test-train split X_train, X_test, y_train, y_test = train_test_split(X_3D, y_one_hot, test_size=0.33, random_state=42) input_shape = (X_train.shape[1], X_train.shape[2]) # store input_shape print "Model Parameters:" print "input_shape : ", input_shape print "X_vector_dim : ", X_vector_dim print "y_vector_dim : ", y_vector_dim # Build Keras TimeDistributed(Dense) (many-to-many case) LSTM model print("Build Keras Timedistributed-LSTM Model...") model = Sequential() model.add( TimeDistributed(Dense(X_vector_dim, activation=_activation), input_shape=input_shape)) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim * 2, activation=_activation))) #(5, 80) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim, activation=_activation))) #(5, 40) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim / 2, activation=_activation))) #(5, 20) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim / 4, activation=_activation))) #(5, 10) model.add(Dropout(_dropout)) model.add( LSTM(X_vector_dim / 4, dropout=_dropout, recurrent_dropout=_dropout)) model.add(Dense(y_vector_dim, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=_optimizer, metrics=['accuracy']) model.summary() # Fit model print('Training...') model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_test, y_test)) # Evaluate Model and Predict Classes print('Testing...') score, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score: {:.3}'.format(score)) print('Test accuracy: {:.3}'.format(accuracy)) # Export model export_model(model, model_path) # serialize model to JSON model_json = model.to_json() with open(json_model_path, "w") as json_file: json_file.write(json_model_path) # serialize weights to HDF5 model.save_weights(model_weights_path) print("Saved model to disk")
def kerasify(self, name): export_model(self.model, 'yinsh.model')
model.compile(loss='categorical_crossentropy', optimizer=_optimizer, metrics=['accuracy']) model.summary() print('Training...') model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_test, y_test)) print('Testing...') score, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score: {:.3}'.format(score)) print('Test accuracy: {:.3}'.format(accuracy)) export_model(model,model_path) # serialize model to JSON model_json = model.to_json() with open(json_model_path, "w") as json_file: json_file.write(json_model_path) # serialize weights to HDF5 model.save_weights(model_weights_path) print("Saved model to disk") if __name__ == "__main__": main()
def kerasify(self, name): export_model(self.model, 'example.model')
#else: # model.add(Dense(predict*NUM_FEATURE)) #api model inputs1 = Input(shape=(train_X.shape[1], train_X.shape[2])) lstm = LSTM(NUM_LSTM, return_sequences=True)() model = Model(inputs=inputs1, outputs=lstm) model.compile(loss='mae', optimizer='adam') # fit network history = model.fit(train_X, train_y, epochs=NUM_EPOCH, batch_size=BATCH_SIZE, validation_data=(test_X, test_y), verbose=2, shuffle=False) #EXPORT MODEL export_model(model, exportname) #SAVE MODEL #model.save(Net_PATH) #with open(HISTORY_PATH, 'wb') as handle: # pickle.dump(history.history, handle, protocol=pickle.HIGHEST_PROTOCOL) # read the history #with open(HISTORY_PATH, 'rb') as handle: # b = pickle.load(handle) # plot history #pyplot.plot(history.history['loss'], label='train') #pyplot.plot(history.history['val_loss'], label='test') #pyplot.legend() #pyplot.show()
model = Sequential() model.add(Dense(units=32, input_dim=pos.shape[1], activation='relu')) model.add(Dropout(0.1)) model.add(Dense(units=64, activation="relu")) model.add(Dropout(0.1)) model.add(Dense(units=1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model model = None # Clearing the NN. model = create_model() checkpointer = ModelCheckpoint(filepath="sprot_training_57_dropout_32_64_1.hdf5", verbose=1, save_best_only=True) earlystopper = EarlyStopping(monitor='val_loss', patience=10, verbose=1) model.fit(X_train, y_train, epochs=1000, batch_size=32000, callbacks=[checkpointer], validation_data=(X_valid, y_valid), verbose=1, shuffle = True) model = load_model("sprot_training_57_dropout_32_64_1.hdf5") # eval tresults = model.evaluate(X_test, y_test) print tresults y_pred = model.predict(X_test, batch_size=8192, verbose=1) y = y_test print 'Calculating AUC...' auroc = roc_auc_score(y, y_pred) auprc = average_precision_score(y, y_pred) print auroc, auprc export_model(model, 'sprot_training_57_dropout_32_64_1.kerasify')
import numpy as np from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D test_x = np.random.rand(100, 10).astype('f') test_y = np.random.rand(100).astype('f') input_shape = 10 num_classes = 1 model = Sequential() model.add(Dense(128, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='sigmoid')) model.compile(loss='mean_squared_error', optimizer='adamax') model.fit(test_x, test_y, nb_epoch=1, verbose=False) input = np.array([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]) print(input.shape) print(input) print(model.predict(input)) from kerasify import export_model export_model(model, 'yinsh.model')
from kerasify import export_model import numpy as np from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM test_x = np.random.rand(10, 10, 10).astype('f') test_y = np.random.rand(10).astype('f') model = Sequential() model.add(LSTM(2, input_shape=(10, 10))) model.add(Dense(1, input_dim=10)) model.compile(loss='mean_squared_error', optimizer='adamax') model.fit(test_x, test_y, epochs=3, verbose=2) print model.predict(np.array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])) print('1') export_model(model, 'example.model') print('2')
def main(): args = firstPassCommandLine() trainF = args.searchInpTrain validF = args.searchInpValid weightF = args.searchWeight validWeightF = args.searchValidWeight testF = args.searchInpTest modelF = args.searchF nepoch = args.nepoch batchSize = args.batchSize # Read weight for each data points weights = load_weight(weightF) # Load data in the svm rank file format trainfeats1, trainlabels1 = load_svmlight(trainF + '.1') trainfeats2, trainlabels1 = load_svmlight(trainF + '.2') #valid_weights = load_weight(validWeightF) #validfeats1, validlabels2 = load_svmlight(validF + '.1') #validfeats2, validlabels2 = load_svmlight(validF + '.2') # Permulation idx = np.random.permutation(trainfeats1.shape[0]) trainfeats1 = trainfeats1[idx, :] trainfeats2 = trainfeats2[idx, :] weights = weights[idx] assert len(weights) == len(trainlabels1), "Length not equal" testfeats_exists = False if testF != None: testfeats1, testlabels1 = load_svmlight(testF + '.1') testfeats2, testlabels2 = load_svmlight(testF + '.2') testfeats_exists = True else: testfeats1 = None testfeats2 = None testlabels = None ## convert to dense array #trainfeats1 = np.array(trainfeats1.todense()) #validfeats1 = np.array(validfeats1.todense()) #trainfeats2 = np.array(trainfeats2.todense()) #validfeats2 = np.array(validfeats2.todense()) # #if testfeats_exists: # testfeats1 = np.array(testfeats1.todense()) # testfeats2 = np.array(testfeats2.todense()) # Create model INPUT_DIM = trainfeats1.shape[1] rankModel, getScore, outNet = getRankModel(INPUT_DIM) target = np.ones((trainfeats1.shape[0])) rankModel.summary() numParams = rankModel.count_params() numDatapts = trainfeats1.shape[0] numPolicies = int(np.round(numDatapts / (numParams * _GROUPS_))) numPolicies = -1 print("###############################") print("###############################") print("###############################") print("###############################") if numPolicies <= 0: numPolicies = 1 group = [range(len(trainfeats1))] else: group = list( chunks(range(0, len(trainfeats1)), int(numParams * _GROUPS_))) ## Train model. allModels = [] for k, cidx in enumerate(group): if k != 0: # Create new models rankModel, getScore, outNet = getRankModel(INPUT_DIM) print('Data size: %d\n' % len(cidx)) #validation_data=([validfeats1, validfeats2], \ # np.ones((validfeats1.shape[0])), valid_weights), \ early_stopping = EarlyStopping(monitor='val_acc', patience=50) history = rankModel.fit([trainfeats1[cidx, :], trainfeats2[cidx, :]], target[cidx], \ sample_weight=weights[cidx], validation_split=0.2, callbacks=[early_stopping], batch_size=batchSize, \ epochs=nepoch, verbose=1, \ shuffle=True) # Add an additional module to normalize the score relS = getScore.predict(trainfeats1[cidx, :], batch_size=batchSize, verbose=1) irrS = getScore.predict(trainfeats2[cidx, :], batch_size=batchSize, verbose=1) allScore = np.hstack((relS.flatten(), irrS.flatten())) maxScore = np.max(allScore) minScore = np.min(allScore) scaleFactor = 1 / (maxScore - minScore) print('Max: %f Min: %f' % (maxScore, minScore)) getScore.add( Dense(1, input_shape=(1, ), weights=[np.ones([1, 1]), -minScore * np.ones((1))])) getScore.add( Dense(1, input_shape=(1, ), weights=[scaleFactor * np.ones([1, 1]), np.zeros((1))])) # Save mode ## Generate scores from document/query features. #relS = getScore.predict(validfeats1, batch_size=batchSize, verbose=1) #irrS = getScore.predict(validfeats2, batch_size=batchSize, verbose=1) #getRank(relS, irrS, 'valid') if testfeats_exists: relS = getScore.predict(testfeats1, batch_size=batchSize, verbose=1) irrS = getScore.predict(testfeats2, batch_size=batchSize, verbose=1) np.savetxt(modelF[:-3] + "rank1.txt", relS) np.savetxt(modelF[:-3] + "rank2.txt", irrS) print("Max score difference: " + str(np.max(relS - irrS))) print("Min score difference: " + str(np.min(relS - irrS))) print("Mean score difference: " + str(np.mean(relS - irrS))) print("Score difference std dev: " + str(np.std(relS - irrS))) getRank(relS, irrS, 'test') # Save mode export_model(getScore, modelF) getScore.save(modelF.replace(".h5", '_%d.h5' % k)) del getScore del rankModel #_, getScore, _= getRankModel(INPUT_DIM) #combine_modules(INPUT_DIM, numPolicies, modelF) be.clear_session() return
import argparse parser = argparse.ArgumentParser() parser.add_argument("input", help="input filepath of keras model file") parser.add_argument("output", help="output filepath of kerasified model file") args = parser.parse_args() print args from keras.models import load_model print "convert keras model:", args.input keras_model = load_model(args.input) import sys sys.path.insert(0, './lib/kerasify') from kerasify import export_model print "to:", args.output export_model(keras_model, args.output) print "done!"
def RunNetwork(epo, dropout, networknum, class_name, Xvector, valpercent, timestep, iteration, dataInfo): timesteps = timestep ## POSE - val_acc: 98% epochs = epo batch_size = 32 _dropout = dropout _activation = 'relu' _optimizer = 'Adam' class_names = class_name # 4 classes X_vector_dim = Xvector # number of features or columns (pose) samples_path = "data.txt" # 311 files with 10 frames' human-pose estimation keypoints(10*18) labels_path = "label.txt" # 311 files' labels, 3 classes in total if os.path.isdir(str(iteration)) == True: pass else: os.makedirs(str(iteration)) model_path = str(iteration) + '/pose.model' json_model_path = str(iteration) + '/pose_model.json' model_weights_path = str(iteration) + '/pose_model.h5' X = np.loadtxt(samples_path, dtype="float") y = np.loadtxt(labels_path) def samples_to_3D_array(_vector_dim, _vectors_per_sample, _X): X_len = len(_X) result_array = [] for sample in range(0, X_len): # should be the 311 samples? sample_array = [] for vector_idx in range(0, _vectors_per_sample): start = vector_idx * _vector_dim end = start + _vector_dim sample_array.append(_X[sample][start:end]) result_array.append(sample_array) return np.asarray(result_array) X_vectors_per_sample = timesteps # number of vectors per sample , 5 samples X_3D = samples_to_3D_array(X_vector_dim, X_vectors_per_sample, X) def convert_y_to_one_hot( _y ): # one hot encoding simply means : red --> 0 , green --> 1 , blue --> 2 _y = np.asarray(_y, dtype=int) b = np.zeros((_y.size, _y.max() + 1)) b[np.arange(_y.size), _y] = 1 return b y_one_hot = convert_y_to_one_hot(y) y_vector_dim = y_one_hot.shape[1] X_train, X_test, y_train, y_test = train_test_split(X_3D, y_one_hot, test_size=valpercent, random_state=42) input_shape = (X_train.shape[1], X_train.shape[2]) model = Sequential() model.add( TimeDistributed(Dense(X_vector_dim, activation=_activation), input_shape=input_shape)) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim * 2, activation=_activation))) # (5, 80) model.add(Dropout(_dropout)) model.add(TimeDistributed(Dense(X_vector_dim, activation=_activation))) # (5, 40) model.add(Dropout(_dropout)) model.add( TimeDistributed(Dense(int(X_vector_dim / 2), activation=_activation))) # (5, 20) model.add(Dropout(_dropout)) model.add( TimeDistributed(Dense(int(X_vector_dim / 4), activation=_activation))) # (5, 10) model.add(Dropout(_dropout)) model.add( LSTM(int(X_vector_dim / 4), dropout=_dropout, recurrent_dropout=_dropout)) model.add(Dense(y_vector_dim, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=_optimizer, metrics=['accuracy']) NetworkInfo = '*2_*1_/2_/4' class TrainingVisualizer(keras.callbacks.History): def on_epoch_end(self, epoch, logs={}): super(TrainingVisualizer, self).on_epoch_end(epoch, logs) IPython.display.clear_output(wait=True) # 生成TrainingVisualizer图片 if epoch == epochs - 1: axes = pd.DataFrame(self.history).plot() axes.axvline(x=max( (val_acc, i) for i, val_acc in enumerate(self.history['val_acc']))[1]) print('Training...') model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_test, y_test), callbacks=[TrainingVisualizer()]) score, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size) doc = open('result.txt', 'a') print(iteration, file=doc) print('Test score: {:.3}'.format(score), file=doc) print('Test accuracy: {:.3}'.format(accuracy), file=doc) doc.close() y_pred = model.predict(X_test) def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') print(cm) plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) fmt = '.2f' if normalize else 'd' thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, format(cm[i, j], fmt), horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') if os.path.isdir("graph/Confusion_Matrix") == True: pass else: os.makedirs("graph/Confusion_Matrix") plt.savefig('graph/Confusion_Matrix/CM_' + str(iteration)) plt.close() # Compute confusion matrix cnf_matrix = confusion_matrix(np.argmax(y_test, axis=1), np.argmax(y_pred, axis=1)) np.set_printoptions(precision=2) # Plot non-normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix, without normalization') # plt.show() if os.path.isdir("graph/TrainingVisualizer") == True: pass else: os.makedirs("graph/TrainingVisualizer") plt.savefig('graph/TrainingVisualizer/TV_' + str(iteration)) export_model(model, model_path) print("Model saved to disk") model_json = model.to_json() with open(json_model_path, "w") as json_file: json_file.write(json_model_path) # serialize weights to HDF5 model.save_weights(model_weights_path) print("Saved model to disk") docdes = open('description.txt', 'a') docdes.write(str(iteration) + "\n") docdes.write("Data source: " + dataInfo + "\n") docdes.write("Network: " + NetworkInfo + "\n") docdes.write("epochs: " + str(epo) + "\n") docdes.write("dropout: " + str(dropout) + "\n") docdes.write("Validation percentage: " + str(valpercent) + "\n") docdes.write('\n') docdes.close
#sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) #model.compile(loss='categorical_crossentropy', optimizer=sgd) model.compile(loss='mse', optimizer='adam', metrics=['mse', 'mae']) print(np.shape(x_train)) print(np.shape(y_train)) model.fit(x_train, y_train, batch_size=32, epochs=100) score = model.evaluate(x_train, y_train, batch_size=32) print(score) #model export for SuperCollider from kerasify import export_model export_model(model, 'DNN1.model') #model export for javascript import onnxmltools #from keras.models import load_model # Update the input name and path for your Keras model #input_keras_model = 'model.h5' # Change this path to the output name and path for the ONNX model output_onnx_model = '/Users/ioi/Desktop/onnxoutput/modelcheck.onnx' # Load your Keras model #keras_model = load_model(input_keras_model) # Convert the Keras model into ONNX
for label_num in range(len(LABEL_NAMES)): (loaded_labels, loaded_data, loaded_tests_labels, loaded_tests) = load_samples(label_num) data_labels = np.append(data_labels, loaded_labels) data = np.append(data, loaded_data, axis=0) tests_labels = np.append(tests_labels, loaded_tests_labels) tests = np.append(tests, loaded_tests, axis=0) # Try with only the torso keypoints which are 0-7 * (x,y) data = data[:, 0:16] tests = tests[:, 0:16] data = tf.keras.utils.normalize(data, axis=1) tests = tf.keras.utils.normalize(tests, axis=1) model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(64, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(64, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(3, activation=tf.nn.softplus)) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) start_time = time.time() model.fit(data, data_labels, epochs=100, batch_size=2) val_loss, val_acc = model.evaluate(tests, tests_labels) elapsed_time = time.time() - start_time print("Final Loss: {} Final Accuracy:{} Total Time:{}s".format(val_loss, val_acc, elapsed_time)) export_model(model, os.path.join(output_dir, 'raised-hands-upper-body-only.model'))
def main(args): tensorflow_shutup() model = load_model(args.model) export_model(model, "tmp/" + args.name + ".temp") curdir = os.path.dirname(os.path.abspath(__file__)) dirs = curdir.split("\\") curdir = ("/").join(dirs[0:-1]) with open("source/" + args.name + ".cpp", "w") as f: f.write('''// Auto-generated by keraport.py, do not modify #include <iostream> #include <fstream> #include <math.h> #include <string.h> #include "mex.hpp" #include "mexAdapter.hpp" #include "keras_model.hpp" #include <memory> class MexFunction : public matlab::mex::Function { matlab::data::ArrayFactory factory; std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine(); std::ostringstream stream; public: void operator() (matlab::mex::ArgumentList outputs, matlab::mex::ArgumentList inputs) { //checkArguments(outputs, inputs); bool bypass; if (inputs[inputs.size() - 1].getType() == matlab::data::ArrayType::LOGICAL) { bypass = inputs[inputs.size() - 1][0]; } else { bypass = false; } if (bypass == true) { mexPrintf("**Ignoring errors for dimensions**"); } // implementation for multiple predictions for (int i = 0; i < inputs.size(); i++) { if (inputs[i].getType() == matlab::data::ArrayType::DOUBLE) { matlab::data::TypedArray<double> doubleArray = std::move(inputs[i]); std::vector<float> vectorFloats; for (auto& elem : doubleArray) { vectorFloats.push_back((float)elem); } std::vector<float> VecOut = predict(vectorFloats, bypass); std::vector<double> doubleVec; for (auto elem : VecOut) { doubleVec.push_back((double)elem); } matlab::data::TypedArray<double> doubleOut = factory.createArray({ 1,doubleVec.size() }, doubleVec.begin(), doubleVec.end()); outputs[i] = std::move(doubleOut); } else if (bypass==true && i == inputs.size()-1) { //do nothing } else { mexError("Input must be a double array"); } } } void mexPrintf(std::string stream) { // Pass stream content to MATLAB fprintf function matlabPtr->feval(u"fprintf", 0, std::vector<matlab::data::Array>({ factory.createScalar(stream) })); } void mexError(std::string stream) { // Pass stream content to MATLAB fprintf function matlabPtr->feval(u"error", 0, std::vector<matlab::data::Array>({ factory.createScalar(stream) })); } std::vector<float> predict(std::vector<float> input, int bypass) { KerasModel model; model.LoadModel("%s/tmp/%s.temp"); Tensor in(input.size()); in.data_ = input; Tensor out; //test if dimensions match //KerasLayer* layer = model.layers_[0]; std::string str = model.firstlayer_->Check(&in); if (str != "true" && bypass == false) { mexError(str); } model.Apply(&in, &out); return out.data_; } };''' % (curdir, args.output))
def main(): args = firstPassCommandLine() trainF = args.pruneInpTrain validF = args.pruneInpValid weightF = args.pruneWeight validWeightF = args.pruneValidWeight testF = args.pruneInpTest modelF = args.pruneF nepoch = args.nepoch batchSize = args.batchSize # Load sample weights weights = load_weight(weightF) valid_weights = load_weight(validWeightF) # Load data in the svm rank file format trainfeats, trainlabels = load_svmlight(trainF) validfeats, validlabels = load_svmlight(validF) testfeats_exists = False #weights = weights[:len(trainlabels)] valid_weights = valid_weights[:len(validlabels)] if testF != None: testfeats, testlabels = load_svmlight(testF) testfeats_exists = True else: testfeats = None testlabels = None # convert to dense array trainfeats = np.array(trainfeats.todense()) validfeats = np.array(validfeats.todense()) if testfeats_exists: testfeats = np.array(testfeats.todense()) # concatenate weights to data points for oversampling trainfeats_weights = np.hstack( (trainfeats, np.reshape(weights, (len(weights), 1)))) validfeats_weights = np.hstack( (validfeats, np.reshape(valid_weights, (len(valid_weights), 1)))) # Apply the random over-sampling ros = RandomOverSampler() trainfeats_weights_ros, trainlabels_ros = ros.fit_sample( trainfeats_weights, trainlabels) validfeats_weights_ros, validlabels_ros = ros.fit_sample( validfeats_weights, validlabels) trainfeats_ros = trainfeats_weights_ros[:, :-1] trainweights_ros = trainfeats_weights_ros[:, -1] validfeats_ros = validfeats_weights_ros[:, :-1] validweights_ros = validfeats_weights_ros[:, -1] if testfeats_exists: testfeats_ros, testlabels_ros = ros.fit_sample(testfeats, testlabels) # Reset labels (not needed anymore since for neural nets, we use labels of 0 and 1 in trj files) #trainlabels[np.where(trainlabels==-1)[0]] = 0 #validlabels[np.where(validlabels==-1)[0]] = 0 #if testfeats != None: # testlabels[np.where(testlabels==-1)[0]] = 0 # Create model INPUT_DIM = trainfeats.shape[1] pruneModel = getPruneModel(INPUT_DIM) pruneModel.summary() ## Train model. early_stopping = EarlyStopping(monitor='val_loss', patience=20) history = pruneModel.fit(trainfeats_ros, trainlabels_ros, batch_size=batchSize, \ sample_weight=trainweights_ros, epochs=nepoch, verbose=1, validation_data=(validfeats_ros, validlabels_ros, validweights_ros), callbacks=[early_stopping], shuffle=True) # Evaluate on training train_preds = pruneModel.predict_classes(trainfeats) train_eval_ = pruneModel.evaluate(trainfeats, trainlabels, verbose=1) print("[Loss, accuracy] = " + str(train_eval_)) print("Precision = " + str(precision_score(trainlabels, train_preds))) print("Recall = " + str(recall_score(trainlabels, train_preds))) train_preds = pruneModel.predict_classes(trainfeats) train_eval_ = pruneModel.evaluate(trainfeats, trainlabels, verbose=1) print("[Loss, accuracy] (randomly oversampled) = " + str(train_eval_)) print("Precision (randomly oversampled) = " + str(precision_score(trainlabels, train_preds))) print("Recall (randomly oversampled) = " + str(recall_score(trainlabels, train_preds))) # Evaluate on test eval_ = pruneModel.evaluate(validfeats, validlabels, verbose=1) if testfeats_exists: eval_ = pruneModel.evaluate(testfeats, testlabels, verbose=1) print("[Test loss, test accuracy] = " + str(eval_)) eval_ = pruneModel.evaluate(testfeats, testlabels, verbose=1) print("[Test loss, test accuracy] (randomly oversampled) = " + str(eval_)) # Save mode print('Creating: ' + modelF) export_model(pruneModel, modelF) pruneModel.save(modelF[:-3] + "_keras.h5") del pruneModel be.clear_session() return