def run_network_lambda(): np.random.seed(12345678) training_data, validation_data, test_data = ld.load_data( 'training_data_clean', 'validation_data_clean', 'test_data_clean', 300) results = [] for re_lambda in RE_LAMBDA: net = nn.NeuralNetwork([300, 30, 2]) results.append( net.stochastic_gradient_descent(training_data, NUM_ITERATIONS, 10, learning_rate=0.1, re_lambda=re_lambda, validation_data=validation_data, show_validation_accuracy=True)) f = open("multiple_lambda.json", "w") json.dump(results, f) f.close()
def run_network_eta(): np.random.seed(12345678) training_data, validation_data, test_data = ld.load_data( 'training_data_clean', 'validation_data_clean', 'test_data_clean', 300) results = [] for eta in LEARNING_RATES: net = nn.NeuralNetwork([300, 30, 2]) results.append( net.stochastic_gradient_descent(training_data, NUM_ITERATIONS, 10, eta, re_lambda=0.0, validation_data=validation_data, show_training_cost=True)) f = open("multiple_eta.json", "w") json.dump(results, f) f.close()
def run_network_feature(): np.random.seed(12345678) results = [] for num_feature in NUM_FEATURES: training_data, validation_data, test_data = ld.load_data( 'training_data_clean', 'validation_data_clean', 'test_data_clean', num_feature) net = nn.NeuralNetwork([num_feature, 30, 2]) results.append( net.stochastic_gradient_descent(training_data, NUM_ITERATIONS, 10, learning_rate=0.1, re_lambda=0.1, validation_data=validation_data, show_validation_accuracy=True)) f = open("multiple_feature.json", "w") json.dump(results, f) f.close()
def return_suggested(pred_list): ''' INPUT: list of preferences for episode OUTPUT: suggested episode information Return the top episode for the preferences passed in ''' # extract features char = pred_list[0] location = pred_list[1] val = pred_list[2] song = pred_list[3] politics = pred_list[4] recommended_id = initialize(char, location, val, song, politics).head(1).values print('rec id = ', recommended_id) df = ld.load_data() for row in df.as_matrix(): if row[0] == recommended_id: return [row[-1], row[8], row[10], row[11], row[12]]
def evaluate_model(learning_rate=0.005, n_epochs=50, nkerns=[16, 40, 50, 60], batch_size=32): """ Network for classification :type learning_rate: float :param learning_rate: this is the initial learning rate used (factor for the stochastic gradient) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type nkerns: list of ints :param nkerns: number of kernels on each layer :type batch_size: int :param batch_size: the batch size for training """ print("Evaluating model") rng = numpy.random.RandomState(23455) # loading the data datasets = load_data(3) train_set_x, train_set_y = datasets[0] valid_set_x, valid_set_y = datasets[1] test_set_x, test_set_y = datasets[2] # compute number of minibatches for training, validation and testing n_train_batches = train_set_x.get_value(borrow=True).shape[0] n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] n_test_batches = test_set_x.get_value(borrow=True).shape[0] n_train_batches //= batch_size n_valid_batches //= batch_size n_test_batches //= batch_size # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch # start-snippet-1 x = T.matrix('x') # the data is presented as rasterized images y = T.ivector('y') # the labels are presented as 1D vector of # [int] labels ###################### # BUILD ACTUAL MODEL # ###################### print('Building the model...') layer0_input = x.reshape((batch_size, 1, 64, 88)) layer0 = MyConvPoolLayer(rng, input=layer0_input, image_shape=(batch_size, 1, 64, 88), p1=2, p2=2, filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2)) layer1 = MyConvPoolLayer(rng, input=layer0.output, image_shape=(batch_size, nkerns[0], 32, 44), p1=2, p2=2, filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2)) layer2 = MyConvPoolLayer(rng, input=layer1.output, image_shape=(batch_size, nkerns[1], 16, 22), p1=2, p2=2, filter_shape=(nkerns[2], nkerns[1], 5, 5), poolsize=(2, 2)) layer3_input = layer2.output.flatten(2) # construct a fully-connected sigmoidal layer layer3 = HiddenLayer(rng, input=layer3_input, n_in=nkerns[2] * 8 * 11, n_out=800, activation=T.tanh) # classify the values of the fully-connected sigmoidal layer layer4 = LogisticRegression(input=layer3.output, n_in=800, n_out=6) # the cost we minimize during training is the NLL of the model cost = layer4.negative_log_likelihood(y) predicted_output = layer4.y_pred # create a function to compute the mistakes that are made by the model test_model = theano.function( [index], layer4.errors(y), givens={ x: test_set_x[index * batch_size:(index + 1) * batch_size], y: test_set_y[index * batch_size:(index + 1) * batch_size] }) validate_model = theano.function( [index], layer4.errors(y), givens={ x: valid_set_x[index * batch_size:(index + 1) * batch_size], y: valid_set_y[index * batch_size:(index + 1) * batch_size] }) # create a list of all model parameters to be fit by gradient descent params = layer4.params + layer3.params + layer2.params + layer1.params + layer0.params # create a list of gradients for all model parameters grads = T.grad(cost, params) # the learning rate for batch SGD (adaptive learning rate) l_rate = T.scalar('l_rate', dtype=theano.config.floatX) adaptive_learning_rate = T.scalar('adaptive_learning_rate', dtype=theano.config.floatX) # the momentum SGD momentum = T.scalar('momentum', dtype=theano.config.floatX) # 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 = [] for param in params: previous_step = theano.shared(param.get_value() * 0., broadcastable=param.broadcastable) step = momentum * previous_step - l_rate * T.grad(cost, param) updates.append((previous_step, step)) updates.append((param, param + step)) train_model = theano.function( [index, l_rate, momentum], 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] }) # end-snippet-1 ############### # TRAIN MODEL # ############### print('Training...') # early-stopping parameters patience = 50000 # look as this many examples regardless patience_increase = 2 # wait this much longer when a new best is # found improvement_threshold = 0.995 # a relative improvement of this much is # considered significant validation_frequency = min(n_train_batches, patience // 2) # go through this many # minibatche before checking the network # on the validation set; in this case we # check every epoch best_validation_loss = numpy.inf best_iter = 0 test_score = 0. start_time = timeit.default_timer() epoch = 0 done_looping = False # initializing the adaptive leaning rate adaptive_learning_rate = learning_rate # initializing the momentum momentum = 0.1 a = 0.0001 b = 0.3 while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 if epoch % 5 == 0: # decreasing the learning rate after every 10 epochs adaptive_learning_rate = 0.95 * adaptive_learning_rate # increasing the learning rate after every 10 epochs #momentum = 1.005 * momentum for minibatch_index in range(n_train_batches): iter = (epoch - 1) * n_train_batches + minibatch_index if iter % 100 == 0: print('training @ iter = ', iter) cost_ij = train_model(minibatch_index, adaptive_learning_rate, momentum) if (iter + 1) % validation_frequency == 0: # compute zero-one loss on validation set validation_losses = [ validate_model(i) for i in range(n_valid_batches) ] this_validation_loss = numpy.mean(validation_losses) print('epoch %i, minibatch %i/%i, validation error %f %%' % (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100.)) # if we got the best validation score until now if this_validation_loss < best_validation_loss: # increase the learning rate by small amount (adaptive) adaptive_learning_rate += a #improve patience if loss improvement is good enough if this_validation_loss < best_validation_loss * \ improvement_threshold: patience = max(patience, iter * patience_increase) # save best validation score and iteration number best_validation_loss = this_validation_loss best_iter = iter #Save the model print("Saving model") save_filename = "../saved_models/model3" x = numpy.array([ layer4.W.get_value(), layer4.b.get_value(), layer3.W.get_value(), layer3.b.get_value(), layer2.W.get_value(), layer2.b.get_value(), layer1.W.get_value(), layer1.b.get_value(), layer0.W.get_value(), layer0.b.get_value() ]) numpy.save(save_filename, x) # f = file(save_filename, 'wb') # # cPickle.dump([param.get_value() for param in params], f, protocol=cPickle.HIGHEST_PROTOCOL) # cPickle.dump([param.get_value() for param in params], f, protocol=cPickle.HIGHEST_PROTOCOL) # # cPickle.dump(params, f, protocol=cPickle.HIGHEST_PROTOCOL) # test it on the test set test_losses = [ test_model(i) for i in range(n_test_batches) ] test_score = numpy.mean(test_losses) print((' epoch %i, minibatch %i/%i, test error of ' 'best model %f %%') % (epoch, minibatch_index + 1, n_train_batches, test_score * 100.)) else: # decrease the learning rate by small amount (adaptive) adaptive_learning_rate = adaptive_learning_rate - ( b * adaptive_learning_rate) + (0.01 * a) if patience <= iter: done_looping = True break end_time = timeit.default_timer() print('Optimization complete.') print('Best validation score of %f %% obtained at iteration %i, ' 'with test performance %f %%' % (best_validation_loss * 100., best_iter + 1, test_score * 100.)) print( ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)
pt.run_network_lambda() pt.make_plot_lambda() # it fluctuates a lot, need more investigation on this, select lambda=0.1 for now # 3) tunning the optimal # of features based on the validation data accuracy # use learning_rate = 0.1, re_lambda = 0.1 pt.run_network_feature() pt.make_plot_feature() # feature size = 300 is selected based on the plot figure # 4) tunning the optimal # of neurons based on the validation data accuracy # use learning_rate = 0.1, re_lambda = 0.1, num_features = 300 pt.run_network_neuron() pt.make_plot_neuron() # select neuron = 100 # 5) based on those selected hyperparameters, plot the training accuracy and validation accuracy # learning_rate = 0.1, re_lambda = 0.1, batch_size=100, num_feature = 300, neuron = 100 training_data, validation_data, test_data = ld.load_data('training_data_clean', 'validation_data_clean', 'test_data_clean', 300) net = nn.NeuralNetwork([300, 100, 2]) training_cost, training_accuracy, validation_cost, validation_accuracy = \ net.stochastic_gradient_descent(training_data, iterations=50, batch_size=10, learning_rate=0.1, re_lambda=0.1, validation_data=validation_data, show_training_cost=False, show_training_accuracy=True, show_validation_cost=False, show_validation_accuracy=True) f = open("accuracy.json", "w") json.dump([training_accuracy, validation_accuracy], f) f.close() f = open("accuracy.json", "r")
# MLP for Pima Indians Dataset Serialize to JSON and HDF5 import tensorflow as tf from tensorflow import keras #hep libraries import numpy as np import matplotlib.pyplot as plt #my libraries import loading_data as ld import frequency as freq import os ((x_train, y_train),(x_test, y_test))=ld.load_data() def get_key(key_array): for i in range(0,len(key_array)): if key_array[i]==1: return i+1 # load json and create model json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = tf.keras.models.model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") # evaluate loaded model on test data loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) score = loaded_model.evaluate(x_train[1], y_train, verbose=0) print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))
from flask import Flask, request, render_template, session import loading_data as ld from sklearn.externals import joblib import numpy as np import pandas as pd import os app = Flask(__name__, static_url_path="", static_folder="static") # load data from loading_data.py df = ld.load_data() # Home page with options to predict rides or runs @app.route('/', methods=['GET']) def index(): ''' Main page html render - no input ''' return render_template('index.html') # This is the How it Works page describing the recommender @app.route('/how_it_works', methods=['GET']) def how_it_works(): ''' How it Works render - no input ''' return render_template('how_it_works_blog_post.html')
"""This is the class to be used for generating the visualization. It prompts the user to enter the url to the data file and will create the visualization in html format in the user's working directory.""" #prompt the user to get the most recent data file url print("Please refer to https://www.metoffice.gov.uk/hadobs/hadcrut4/data/current/time_series \ and paste the link to most recent data file here:") url=input() from urllib.parse import quote #encode the url urlenc=quote(url) #load the data into a Pandas dataframe and return a #cleaned version from loading_data import load_data hadcrut=load_data(url) #create the visualization from loading_viz import load_viz result=load_viz(hadcrut) print(result)