def query(): """Perform inference on some examples of documents from our classes.""" tf.logging.set_verbosity(FLAGS.verbosity) classes = get_data(FLAGS.data_dir, classes_only=True) FLAGS.output_dim = len(classes) queries = np.loadtxt(FLAGS.query_file, dtype=str, delimiter='\n') _, x_query, _, query_lengths, _, _ = process_vocabulary( None, queries, FLAGS, reuse=True, sequence_lengths=FLAGS.model == 'rnn') if FLAGS.model == 'perceptron': model = bag_of_words_perceptron_model elif FLAGS.model == 'mlp': model = bag_of_words_MLP_model elif FLAGS.model == 'rnn': model = rnn_model else: raise ValueError('unknown model') classifications = predict(x_query, query_lengths, model, FLAGS) for i, query in enumerate(queries): print('The model classifies "{}" as a member of the class {}.'.format( query, classes['class'][classifications[i]]))
def test_cnn_lstm(): props = { 'nb_epoch': 1, 'batch_size': 64, } model, hist = fit_model_cnn_lstm(props, char_limit=1000) kbrd = common.keyboardIOS7() l = common.generate_input('man', 100, kbrd) pred = common.predict(model, kbrd, l) print(pred)
def op0(): """ generate lowest 15000 confident images :return: none """ data = common.Data("mnist/mnist_train/train_data.npy", "mnist/mnist_train/mnist_train_label", "mnist/mnist_test/test_data.npy", "mnist/mnist_test/mnist_test_label", 1, 28) res = common.predict('model/1.4.0', 60000, data.train_x, 28) common.gen_data(res, data.train_x, data.train_y_no_one_hot, 15000)
def op1(): """ generate fc2 output for svm :return: none """ data = common.Data("mnist/mnist_train/train_data.npy", "mnist/mnist_train/mnist_train_label", "mnist/mnist_test/test_data.npy", "mnist/mnist_test/mnist_test_label", 1, 28) res = common.predict('CNN/model/SVM1', 60000, data.test_x, 28, "out1") data_fc = [] for i in range(len(res)): data_fc.append(res[i][0][0][0]) data_fc = np.array(data_fc) np.save('mnist/mnist_test/fc1_5.npy', data_fc)
def getModel(): model = Sequential() model.add( LSTM(1000, activation='tanh', input_shape=(4, 1), return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(500, activation='tanh', return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(200, activation='tanh', return_sequences=True)) model.add(Dense(1, activation='linear')) adam = optimizers.Adam(lr=0.0001) model.compile(loss="mean_squared_error", optimizer=adam) return model if __name__ == '__main__': file = common.readData() scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1)) data = common.preprocessData(file, scaler) train_data, test_data = common.splitData(data, 0.8) common.plotTestAndTrain(train_data, test_data) x_train, y_train, x_test, y_test = common.prepareForTraining( train_data, test_data) model = getModel() common.train(x_train, y_train, model, 16, 10, "model01.h5") common.test(model, x_train, y_train, x_test, y_test) common.predict(model, x_test, y_test, scaler)
# f_ = lambda x: x*(x-1)+x f_ = lambda x: np.sin(2*np.pi*x) # Set coefs to interpolant if not dir_bcs: A_values = np.array([f_(mesh)]).T else: A_values = np.array([f_(mesh[1:-1])]).T f, weights = p1_net(x, mesh, dir_bcs=dir_bcs) grad_f = tf.gradients(f, x)[0] # Before starting, initialize the variables init = tf.initialize_all_variables() x_ = np.linspace(0, 1, 1001).astype(np.float64) x_mid = 0.5*(x_[:-1] + x_[1:]) with tf.Session() as sess: sess.run(init) sess.run(weights.assign(A_values)) y_ = predict(sess, f, x, x_) dy_dx_ = predict(sess, grad_f, x, x_mid) plt.figure() plt.plot(x_, y_) plt.plot(x_mid, dy_dx_) plt.plot(x_mid, np.cos(2*np.pi*x_mid)*2*np.pi) plt.show()
# create a list of gradients for all model parameters gparams = T.grad(cost, params) # train_model is a function that updates the model parameters by # SGD Since this model has many parameters, it would be tedious to # manually create an update rule for each model parameter. We thus # create the updates list by automatically looping over all # (params[i], grads[i]) pairs. updates = [(param, param - learning_rate * gparam) for param, gparam in zip(params, gparams)] logger.debug('building training model') train_model = theano.function( inputs=[index], outputs=cost, updates=updates, givens={ x: train_set_x[index * batch_size:(index + 1) * batch_size], y: train_set_y[index * batch_size:(index + 1) * batch_size] }) logger.info('Training the model ...') utils.training.train(classifier, train_model, validate_model, test_model, n_train_batches, n_valid_batches, n_test_batches, n_epochs, learning_rate, patience, patience_increase, improvement_threshold, MODEL, MODEL_ID, logger) logger.info('Testing the model ...') common.predict(MODEL, source, logger) pass
# 3.6.3 バッチ処理 import numpy as np import common as c x, _ = c.get_data() network = c.init_network() W1, W2, W3 = network["W1"], network["W2"], network["W3"] print(x.shape) print(x[0].shape) print(W1.shape) print(W2.shape) print(W3.shape) x, t = c.get_data() batch_size = 100 accuracy_cnt = 0 for i in range(0, len(x), batch_size): x_batch = x[i:i + batch_size] y_batch = c.predict(network, x_batch) p = np.argmax(y_batch, axis=1) accuracy_cnt += np.sum(p == t[i:i + batch_size]) print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
if __name__ == '__main__': import matplotlib.pyplot as plt from common import predict import numpy as np x = tf.placeholder(tf.float32, [None, 1]) NN, params = tooth(x) # Before starting, initialize the variables init = tf.initialize_all_variables() # Launch the graph. with tf.Session() as sess: sess.run(init) # Set the variables as in numpy sess.run(params['A1'].assign(np.array([[1., 1., 1.]]))) sess.run(params['b1'].assign(np.array([0, -0.5, -1.]))) sess.run(params['A2'].assign(np.array([[2, -4, 2]]).T)) sess.run(params['b2'].assign(np.array([0.]))) unit_interval = np.linspace(0, 1, 1000) dNN_dx = tf.gradients(NN, x)[0] dx = predict(sess, dNN_dx, x, unit_interval) plt.figure() plt.plot(unit_interval, predict(sess, NN, x, unit_interval)) plt.plot(unit_interval, dx) plt.show()
m = 4 x = tf.placeholder(tf.float32, [None, 1]) NN, params = saw_tooth(x, m=m) # Before starting, initialize the variables init = tf.initialize_all_variables() A = np.array([[2, -4, 2], [2, -4, 2], [2, -4, 2]]).T b = np.array([0, -0.5, -1]) # Launch the graph. with tf.Session() as sess: sess.run(init) # Set the variables as in numpy sess.run(params['A0'].assign(np.array([[1., 1., 1.]]))) sess.run(params['b0'].assign(np.array([0, -0.5, -1.]))) sess.run(params['Aout'].assign(np.array([[2, -4, 2]]).T)) sess.run(params['bout'].assign(np.array([0.]))) for i in range(1, m): sess.run(params['A%d' % i].assign(A)) sess.run(params['b%d' % i].assign(b)) unit_interval = np.linspace(0, 1, 1001) plt.figure() plt.plot(unit_interval, predict(sess, NN, x, unit_interval)) plt.show()
b0 = np.array([0, 0, 0, -1]) A1 = np.array([[0, 1, 0, 1]]).T b1 = np.array([0]) # Launch the graph. with tf.Session() as sess: # Set the variables as in numpy sess.run(params['A0'].assign(A0)) sess.run(params['b0'].assign(b0)) sess.run(params['A1'].assign(A1)) sess.run(params['b1'].assign(b1)) xx = np.linspace(0, pi, 1001) plt.figure() plt.plot(xx, predict(sess, NN, x, xx)) plt.plot(xx, np.sin(pi * xx) + np.sin(3 * pi * xx - 1)) plt.show() # ------------------------------------------------------------------------- # Can we learn something # ------------------------------------------------------------------------- x = tf.placeholder(tf.float64, [None, 1]) # NN, params = fourier_series(x, m) # NOTE: with hidden layers the interpretation of first layer size # is the number of terms in the series # NN, _ = fourier_series(x, m) NN = deep_fourier(x, hidden_layer_dims=[m, m]) # y = NN(x)
axarr[0].plot(plotdata["batchsize"], plotdata["loss"], 'b--') axarr[0].set_xlabel('Minibatch number') axarr[0].set_ylabel('Loss') axarr[0].set_title('Training Loss') axarr[1].plot(plotdata["batchsize"], plotdata["error"], 'r--') axarr[1].set_xlabel('Minibatch number') axarr[1].set_ylabel('Error') axarr[1].set_title('Training Error') f.tight_layout() plt.show() # Get test data features, labels = data_gen(minibatch_size, num_features, num_classes) print(trainer.test_minibatch({inputs: features, label: labels})) pred = predict(features, z, inputs) eq = pred == labels print("Error (1-acc):", 1.0 - float(sum(eq))/len(eq)) acc_colors = [get_color(label[0], num_classes) for label in labels] pred_colors = [get_color(y[0], num_classes) for y in pred] plt.scatter(features[:,0], features[:,1], c=acc_colors, s=55) plt.scatter(features[:,0], features[:,1], c=pred_colors, marker="x") plt.show() # Visualize boundaries print("Displaying decision boundaries") plt.scatter(features[:,0], features[:,1], c=acc_colors, s=55) part, part_y = particles(500, 5, z, inputs, num_features) part_colors = [get_color(y[0], num_classes) for y in part_y] plt.scatter(part[:,0], part[:,1], c=part_colors, marker="x", alpha=0.5)
# Set the variables as in numpy # For first layer sess.run(params['A0'].assign(np.array([[1., 1., 1.]]))) sess.run(params['b0'].assign(np.array([0, -0.5, -1.]))) sess.run(params['Ac'].assign(Ac)) sess.run(params['bc'].assign(bc)) sess.run(params['Ag'].assign(Ag)) sess.run(params['bg'].assign(bg)) # Collapse last Aout = np.array([np.r_[1., -1. / (2.**(2 * np.arange(1, m + 1)))]]).T bout = np.array([0]) sess.run(params['Aout'].assign(Aout)) sess.run(params['bout'].assign(bout)) #for w in tf.trainable_variables(): # print sess.run(w) unit_interval = np.linspace(0, 1, 1001).astype(np.float64) yL = predict(sess, NN, x, unit_interval) yY = Yaro(unit_interval, m) print np.linalg.norm(yL - yY, np.inf) plt.figure() plt.plot(unit_interval, yL) plt.plot(unit_interval, yY) plt.show()
def train(conv_model_name="../Models/model_conv47.hf5", bilstm_model_name="../Models/model_lstm47.hf5", corpus_path="http://localhost:8983/solr/mikes", excluded_file="excluded.txt"): excluded = [] file = open(excluded_file, encoding="utf-8", mode="r") for w in file: excluded.append(w.strip("\n")) file.close() word2vec, word_len, char2vec, char_len, tag2vec, tag_len, vec2tag, example_array, excluded, test_array \ = prepare_corpus(corpus_path+"/select", 0.0, excluded) print(len(excluded)) print(len(example_array)) print(len(test_array)) # file = open(excluded_file, encoding="utf-8", mode="w") # for w in excluded: # file.write(w+"\n") # file.close() d, l = prepare_dict_simple(corpus_path + "/select") test_array = np.random.permutation(test_array) (_, _, test_xw), (_, _, test_xc), (_, _, test_y), (_, _, test_sw) = \ prepare_sets(word2vec, word_len, char2vec, char_len, tag2vec, tag_len, vec2tag, test_array[:1000], (0.0, 0.0), (0, len(test_array[:1000]))) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3, restore_best_weights=True) print(word_len, char_len) model = create_conv(word_len, char_len, vec2tag, 256, 'lecun_uniform', "Nadam", conv_model_name) for i in range(0): print( str(i) + ". iteration\n-----------------------------------------\n") (train_xw, valid_xw, _), (train_xc, valid_xc, _), (train_y, valid_y, _), _ = \ prepare_sets(word2vec, word_len, char2vec, char_len, tag2vec, tag_len, vec2tag, example_array, (1.0, 0.0), (i*10000, (i+1)*10000)) model.fit([train_xw, train_xc], train_y, batch_size=64, epochs=32, validation_split=0.1, callbacks=[es]) #scores = model.evaluate([test_xw, test_xc], test_y) #print(scores) if i == 0 or i == 15 or i == 31 or i == 47: model.save_weights('model_conv' + str(i) + '.hf5') model1 = create_lstm(word_len, char_len, vec2tag, 256, 'lecun_uniform', 'Nadam', bilstm_model_name) for i in range(0): print( str(i) + ". iteration\n-----------------------------------------\n") (train_xw, valid_xw, _), (train_xc, valid_xc, _), (train_y, valid_y, _), _ = \ prepare_sets(word2vec, word_len, char2vec, char_len, tag2vec, tag_len, vec2tag, example_array, (1.0, 0.0), (i*10000, (i+1)*10000)) model1.fit([train_xw, train_xc], train_y, batch_size=64, epochs=32, validation_split=0.1, callbacks=[es]) #scores = model1.evaluate([test_xw, test_xc], test_y) #print(scores) if i == 0 or i == 15 or i == 31 or i == 47: model1.save_weights('model_lstm' + str(i) + '.hf5') (_, _, test_xw), (_, _, test_xc), (_, _, test_y), (_, _, test_sw) = \ prepare_sets(word2vec, word_len, char2vec, char_len, tag2vec, tag_len, vec2tag, test_array, (0.0, 0.0), (0, len(test_array))) scores = model.evaluate([test_xw, test_xc], test_y) print(scores) scores = model1.evaluate([test_xw, test_xc], test_y) print(scores) hits = 0 pred = model.predict([test_xw, test_xc]) pred1 = model1.predict([test_xw, test_xc]) bywho = [0, 0, 0, 0, 0, 0, 0] # abc, ab, ac, bc, a, b, c for i in range(len(test_array)): if i % 100 == 1: print(str(i) + ". sentence, " + str(hits * 100 / i) + " % acc., ") pred2 = predict(test_sw[i], d, l) if pred[i].argmax(axis=-1) == pred1[i].argmax(axis=-1): chosen = vec2tag[pred[i].argmax(axis=-1)] else: chosen = pred2 if chosen == test_array[i][1]: hits += 1 if test_array[i][1] == vec2tag[pred[i].argmax(axis=-1)]: if test_array[i][1] == vec2tag[pred1[i].argmax(axis=-1)]: if test_array[i][1] == pred2: bywho[0] += 1 else: bywho[1] += 1 elif test_array[i][1] == pred2: bywho[2] += 1 else: bywho[4] += 1 elif test_array[i][1] == vec2tag[pred1[i].argmax(axis=-1)]: if test_array[i][1] == pred2: bywho[3] += 1 else: bywho[5] += 1 elif test_array[i][1] == pred2: bywho[6] += 1 print(hits / len(test_array)) print(bywho) return
param_man.initalise( run_id = MODEL_ID, default_freq = patience, params = new_params, imgs = visualise_weights, cost = visualise_cost, updates = visualise_updates ) # get the training, validation and testing function for the model logger.debug('building fine-tuning functions') train_model, validate_model, test_model = dbn.buildFinetuneFunctions( datasets=datasets, batch_size=batch_size, learning_rate=finetune_lr ) logger.debug('training') utils.training.train(dbn, train_model, validate_model, test_model, n_train_batches, n_valid_batches, n_test_batches, training_epochs, finetune_lr, patience, patience_increase, improvement_threshold, MODEL, MODEL_ID, logger, visualise=param_man ) logger.info('Testing the model ...') common.predict(os.path.join(MODEL, MODEL_ID + ".pkl"), source, logger) pass
threshold = 15 common_path = "../mnist" fig = 28 model_path = 'model/' parent_model = '1.4.0' parent_model_iter = 60000 logger = common.create_logger( 'child', log_format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') data = common.Data(common_path + "/mnist_train/train_data.npy", common_path + "/mnist_train/mnist_train_label", common_path + "/mnist_test/test_data.npy", common_path + "/mnist_test/mnist_test_label", 1, fig) # reference from parent model res = common.predict(model_path + parent_model, parent_model_iter, data.test_x, fig) conf = [] conf_label = [] candidate = [] candidate_label = [] err = 0 for i in range(len(res)): m = np.max(res[i][0][0][0]) temp = [] for j in res[i][0][0][0]: if j < m: temp.append(j) m_ = np.max(temp)
parser.add_argument('--top_k', default=[5], type=int, help='top K classes') parser.add_argument('--category_names', default=['cat_to_name.json'], help='classes to real name') parser.add_argument('--gpu', action='store_true', help='predict in GPU model') args = parser.parse_args() images = args.images checkpoint = args.checkpoint[0] top_k = args.top_k[0] category_names = args.category_names[0] gpu = args.gpu print('checkpoint: {}'.format(checkpoint)) print('TOP K: {}'.format(top_k)) print('category names: {}'.format(category_names)) print('training on GPU: {}'.format(gpu)) model, class_to_idx = common.rebuild_model(checkpoint) with open(category_names, 'r') as f: cat_to_name = json.load(f) for image in images: values, classes = common.predict(image, model, class_to_idx, gpu, top_k) flowers = [cat_to_name[cls] for cls in classes] print('image {}'.format(image)) for flower, prob in zip(flowers, values): print('{} ---> {}'.format(flower, prob)) print('-' * 10)
# # # def init_network(): # with open("sample_weight.pkl", "rb") as f: # network = pickle.load(f) # return network # # # def predict(network, x): # W1, W2, W3 = network["W1"], network["W2"], network["W3"] # b1, b2, b3 = network["b1"], network["b2"], network["b3"] # a1 = np.dot(x, W1) + b1 # z1 = sig.sigmoid(a1) # a2 = np.dot(z1, W2) + b2 # z2 = sig.sigmoid(a2) # a3 = np.dot(z2, W3) + b3 # y = sm.softmax(a3) # return y import numpy as np import common as c x, t = c.get_data() network = c.init_network() accuracy_cnt = 0 for i in range(len(x)): y = c.predict(network, x[i]) p = np.argmax(y) if p == t[i]: accuracy_cnt += 1 print("accuracy:" + str(float(accuracy_cnt) / len(x)))
print("There is no a gpu device available") message_cuda = "cuda is available" if torch.cuda.is_available() else "cuda is not available" print(message_cuda) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = load_checkpoint(checkpoint) model.to(device); class_to_idx = model.class_to_idx probs, classes = predict(path_to_image, model, top_k) if not category_names: print(classes) print(probs) else: name_classes = [] with open(category_names, 'r') as f: cat_to_name = json.load(f) for i in classes: flower_key = recover_key(class_to_idx, i) name_classes.append(cat_to_name[flower_key])