def predict(): """ An example of how to load a trained model and use it to predict labels. """ # load the saved model classifier = pickle.load(open("best_model.p", "rb")) # compile a predictor function predict_model = theano.function( inputs=[classifier.input], outputs=classifier.y_pred) # We can test it on some examples from test test dataset = 'mnist_train.csv' datasets = DataLoader.load_kaggle_mnist(dataset) test_set_x, test_set_y = datasets[2] print(type(test_set_x)) print(type(test_set_y)) test_set_x = test_set_x.get_value() test_set_y = test_set_y.eval() predicted_values = predict_model(test_set_x[20:30]) print("Sample Neural Prediction") print ("Predicted values for the first 20 examples in test set:") print(predicted_values) print ("The actual values are") print(test_set_y[20:30])
def predict_main(classifier_pickle): data = DataLoader.load_kaggle_mnist("mnist_train.csv", neural=False) X = numpy.array(data[2][0]) X = X/255.0*2 - 1 Y = numpy.array(data[2][1]) predictor = MLutil.Predictor(classifier_pickle, 'SVM') predicted_values = predictor.make_prediction(X) predAnalysis = MLutil.PredictionAccuracies(predicted_values, Y) print(predAnalysis.get_misclass_rate()) print(predAnalysis.get_indicies_misclassifications()) pickle.dump(predAnalysis.get_indicies_misclassifications(), open("svm_indicies.p", "wb")) return predAnalysis.get_indicies_misclassifications()
def predict_main(classifier_pickle): print("This functions is being called") datasets = DataLoader.load_kaggle_mnist("mnist_train.csv") test_set_x, test_set_y = datasets[2] test_set_x = test_set_x.get_value() test_set_y = test_set_y.eval() predictor = MLutil.Predictor(classifier_pickle, 'DNN') predicted_values = predictor.make_prediction(test_set_x) predAnalysis = MLutil.PredictionAccuracies(predicted_values, test_set_y) print(predAnalysis.get_misclass_rate()) print(predAnalysis.get_indicies_misclassifications()) pickle.dump(predAnalysis.get_indicies_misclassifications(), open("neural_indicies.p", "wb")) return predAnalysis.get_indicies_misclassifications()
def svm_main(dataset, pickle_model): data = DataLoader.load_kaggle_mnist(dataset, neural=False) classifier = SVM() start = time.time() print("Fitting the svm") X = numpy.array(data[0][0]) X = X/255.0*2 - 1 print(X) Y = numpy.array(data[0][1]) print(len(X)) print(len(Y)) del data classifier.fit_multi(X, Y) fin = time.time() - start print("Awesome, the SVM has been fit, only took {0} seconds".format(fin)) pickle.dump(classifier, open(pickle_model, "wb"))
def validation_analysis(learning_rate=.001, L1_reg=0.00, L2_reg=0.0001, n_epochs=100, dataset='mnist_train.csv', batch_size=20, n_hidden=300, num_layers = 2, mlp_in = 784, mlp_out = 10): """ Main loop for the mlp :type learning_rate: float :param learning_rate: learning rate used (factor for the stochastic gradient :type L1_reg: float :param L1_reg: L1-norm's weight when added to the cost (see regularization) :type L2_reg: float :param L2_reg: L2-norm's weight when added to the cost (see regularization) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type dataset: string :param dataset: path to appropriate dataset :type batch_size: int :param batch_size: number of entries per mini-batch :type n_hidden: int :param n_hidden: number of entries per hidden layer :type num_layers: int :param num_layers: number of hidden layers :type mlp_in: int :param mlp_in: dimension of data loaded from dataset :type mlp_out: int :param mlp_out: number of classes in dataset """ # Load in the data datasets = DataLoader.load_kaggle_mnist(dataset) 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 = math.floor(train_set_x.get_value(borrow=True).shape[0] / batch_size) n_valid_batches = math.floor(valid_set_x.get_value(borrow=True).shape[0] / batch_size) n_test_batches = math.floor(test_set_x.get_value(borrow=True).shape[0] / batch_size) ###################### # BUILD ACTUAL MODEL # ###################### print('... building the model') # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch x = T.matrix('x') # n data entries, m features per entry ==> n by m matrix of data y = T.ivector('y') # the labels are presented as 1D vector of # [int] labels # Seed the random number generator rng = numpy.random.RandomState(1234) # construct the MLP class (the neural net) classifier = MLP( rng=rng, input=x, n_in = mlp_in, n_hidden=n_hidden, n_out=mlp_out, num_layers=num_layers ) # the cost we minimize during training is the negative log likelihood of # the model plus the regularization terms (L1 and L2); cost is expressed # here symbolically cost = ( classifier.negative_log_likelihood(y) + L1_reg * classifier.L1 + L2_reg * classifier.L2_sqr ) # compiling a Theano function that computes the mistakes that are made # by the model on a minibatch test_model = theano.function( inputs=[index], outputs=classifier.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( inputs=[index], outputs=classifier.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] } ) # compute the gradient of cost with respect to theta (stored in params) # the resulting gradients will be stored in a list gparams gparams = [T.grad(cost, param) for param in classifier.params] # specify how to update the parameters of the model as a list of # (variable, update expression) pairs # given two lists of the same length, A = [a1, a2, a3, a4] and # B = [b1, b2, b3, b4], zip generates a list C of same size, where each # element is a pair formed from the two lists : # C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)] updates = [ (param, param - learning_rate * gparam) for param, gparam in zip(classifier.params, gparams) ] # compiling a Theano function `train_model` that returns the cost, but # in the same time updates the parameter of the model based on the rules # defined in `updates` 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] } ) ############### # TRAIN MODEL # ############### print('... training') # early-stopping parameters patience = 10000 # 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 while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 #old_classifier = copy.deepcopy(classifier) for minibatch_index in range(n_train_batches): minibatch_avg_cost = train_model(minibatch_index) # iteration number iter = (epoch - 1) * n_train_batches + minibatch_index 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: #improve patience if loss improvement is good enough if ( this_validation_loss < best_validation_loss * improvement_threshold ): patience = max(patience, iter * patience_increase) best_validation_loss = this_validation_loss best_iter = iter # 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.)) pickle.dump(classifier, open("best_model.p", "wb")) # Otherwise, reduce the learning rate (need to fix this/do this in a better way) ''' else: classifier = old_classifier learning_rate = learning_rate / 2 print("Learning rate halved ... the new learning rate is {0}".format(learning_rate)) ''' if patience <= iter: done_looping = True break end_time = timeit.default_timer() print(('Optimization complete. 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.))
def evaluate_lenet5(learning_rate=0.1, n_epochs=200, dataset='mnist_train.csv', nkerns=[20, 50], batch_size=500, image_height = 28, image_width = 28, filter_height = 5, filter_width = 5, hidden_size = 500, pool_size = (2,2), num_classes = 10, num_standard_layers = 1): """ Demonstrates lenet on MNIST dataset :type learning_rate: float :param learning_rate: learning rate used (factor for the stochastic gradient) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type dataset: string :param dataset: path to the dataset used for training /testing (MNIST here) :type nkerns: list of ints :param nkerns: number of kernels on each layer """ rng = numpy.random.RandomState(23455) datasets = DataLoader.load_kaggle_mnist(dataset) #datasets = load_data(dataset) 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 = math.floor(n_train_batches / batch_size) n_valid_batches = math.floor(n_valid_batches / batch_size) n_test_batches = math.floor(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') # Reshape matrix of rasterized images of shape (batch_size, 28 * 28) # to a 4D tensor, compatible with our LeNetConvPoolLayer # (28, 28) is the size of MNIST images. layer0_input = x.reshape((batch_size, 1, image_height, image_width)) # Construct the first convolutional pooling layer: # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24) # maxpooling reduces this further to (24/2, 24/2) = (12, 12) # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12) layer0 = LeNetConvPoolLayer( rng, input=layer0_input, image_shape=(batch_size, 1, image_height, image_width), filter_shape=(nkerns[0], 1, filter_height, filter_width), poolsize=pool_size ) # Construct the second convolutional pooling layer # filtering reduces the image size to (12-5+1, 12-5+1) = (8, 8) # maxpooling reduces this further to (8/2, 8/2) = (4, 4) # 4D output tensor is thus of shape (batch_size, nkerns[1], 4, 4) new_height = int((image_height - filter_height + 1) / pool_size[0]) new_width = int((image_width - filter_width + 1) / pool_size[1]) print(new_height, new_width) layer1 = LeNetConvPoolLayer( rng, input=layer0.output, image_shape=(batch_size, nkerns[0], new_height, new_width), filter_shape=(nkerns[1], nkerns[0], filter_height, filter_width), poolsize=pool_size ) # Again, after filtering/pooling, find new dimension new_height = int((new_height - filter_height + 1) / pool_size[0]) new_width = int((new_width - filter_width + 1) / pool_size[1]) print(new_height, new_width) # the HiddenLayer being fully-connected, it operates on 2D matrices of # shape (batch_size, num_pixels) (i.e matrix of rasterized images). # This will generate a matrix of shape (batch_size, nkerns[1] * 4 * 4), # or (500, 50 * 4 * 4) = (500, 800) with the default values. layer2_input = layer1.output.flatten(2) # construct a fully-connected sigmoidal layer layer2 = HiddenLayer( rng, input=layer2_input, n_in=nkerns[1] * new_height * new_width, n_out=hidden_size, activation=T.tanh ) # classify the values of the fully-connected sigmoidal layer layer3 = LogisticRegression(input=layer2.output, n_in=hidden_size, n_out=num_classes) # the cost we minimize during training is the NLL of the model cost = layer3.negative_log_likelihood(y) # create a function to compute the mistakes that are made by the model test_model = theano.function( [index], layer3.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], layer3.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 = layer3.params + layer2.params + layer1.params + layer0.params # create a list of gradients for all model parameters grads = 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_i, param_i - learning_rate * grad_i) for param_i, grad_i in zip(params, grads) ] train_model = theano.function( [index], 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 = 10000 # 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 while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 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) 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: #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 # 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.)) 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.)) '''