def recognizing(imageData, loadedFile='data.pkl', kernels=[8, 10]): """ Load the data and build the CNN which have been trained. Then print the result. """ dataBase, manLabel = loading(imageData) prm0, prm1, prm2, prm3 = load_save_data.loadData(loadedFile) m = T.matrix('m') inputData = m.reshape((dataBase.shape[0], 1, 57, 47)) l0 = CNN.ConvPoolLayer(inputData=inputData, filterShape=(kernels[0], 1, 5, 5), imageShape=(dataBase.shape[0], 1, 57, 47), poolsize=(2, 2), weights=prm0[0], biases=prm0[1]) l1 = CNN.ConvPoolLayer(inputData=l0.output, filterShape=(kernels[1], kernels[0], 5, 5), imageShape=(dataBase.shape[0], kernels[0], 26, 21), poolsize=(2, 2), weights=prm1[0], biases=prm1[1]) l2 = CNN.HiddenLayer(inputData=l1.output.reshape( (dataBase.shape[0], kernels[1] * 11 * 8)), numIn=kernels[1] * 11 * 8, numOut=2000, weights=prm2[0], biases=prm2[1], activation=T.tanh) l3 = CNN.LogisticRegression(inputData=l2.output, numIn=2000, numOut=40, weights=prm3[0], biases=prm3[1]) func = theano.function([m], l3.yRslt) result = func(dataBase) """for ind in range(dataBase.shape[0]): if result[ind] != manLabel[ind]: print ('%i is mis-predicted as %i' % (manLabel[ind], result[ind])) img1 = dataBase[ind].reshape((57, 47)) plt.subplot(121) plt.imshow(img1) pylab.gray() img2 = dataBase[result[ind] * 10].reshape((57, 47)) plt.subplot(122) plt.imshow(img2) pylab.gray() pylab.show() """ #first term is age and second term is gender if int(gender_matrix[result[0]]) == 0: gender = "male" else: gender = "female" print old_matrix[result[0]], ' ', gender
def train(self): # self.trainBuntton["state"] = 'disabled' #sizes, epochs, eta, update_queue, validation_threshold, error_threshold trainingPercent = int(self.trainingPercent.get()) epochs = int(self.epochs.get()) et = float(self.error_threshold.get()) vt = int(self.validation_threshold.get()) poolinRule = self.poolingRule.get() mini_batch_size = int(self.mini_batch_size.get()) try: import pickle weights = pickle.load(open(self.address.get(), "rb")) except: weights = None if not self.plotter.is_alive(): self.plotter.start() if self.cnn is not None: if self.cnn.exitcode != 0: print 'Another learner is working.' return self.cnn.terminate() # # self.cnn = CNN.Network(sizes, epochs, eta, mu, self.updatesQueue, vt, et, widrow, bs, activationFunc, weights) # self.cnn = CNN.Network([CNN.ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2)), # CNN.FullyConnectedLayer(n_in=20*12*12, n_out=100), # CNN.SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size, self.updatesQueue) self.cnn = CNN.Network([ CNN.ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2)), CNN.ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(30, 20, 5, 5), poolsize=(2, 2)), CNN.ConvPoolLayer(image_shape=(mini_batch_size, 30, 4, 4), filter_shape=(40, 30, 2, 2), poolsize=(3, 3)), CNN.FullyConnectedLayer(n_in=40 * 1 * 1, n_out=100), CNN.SoftmaxLayer(n_in=100, n_out=10) ], mini_batch_size, self.updatesQueue) self.cnn.start()
def DataTraining(learningRate=0.05, epochs=200, imageData='olivettifaces.gif', kernels=[8, 10], batchsize=40): """ This is the training function, kind of like relaxation step. First, give a number(here I choose 23333) to generate random number and load the data. Then construct the convolution neural network(It's a hard part, by debugging and debugging the parameters) After constructing, we will build three models, and use SGD in training model. Then training. """ rng = numpy.random.RandomState(23333) imageData = load_save_data.loadImageData(imageData) trainX, trainY = imageData[0] validX, validY = imageData[1] testX, testY = imageData[2] numTrainBatches = trainX.get_value(borrow=True).shape[0] / batchsize numValidBatches = validX.get_value(borrow=True).shape[0] / batchsize numTestBatches = testX.get_value(borrow=True).shape[0] / batchsize index = T.lscalar() x = T.matrix('x') y = T.ivector('y') inputData = x.reshape((batchsize, 1, 57, 47)) l0 = CNN.ConvPoolLayer(inputData=inputData, filterShape=(kernels[0], 1, 5, 5), imageShape=(batchsize, 1, 57, 47), poolsize=(2, 2), rng=rng) # 26 = (57 - 5) / 2, 21 = (47 - 5) / 2 l1 = CNN.ConvPoolLayer(inputData=l0.output, filterShape=(kernels[1], kernels[0], 5, 5), imageShape=(batchsize, kernels[0], 26, 21), poolsize=(2, 2), rng=rng) # 11 = (26 - 5 + 1) / 2, 8 = (21 - 5) / 2 l2 = CNN.HiddenLayer(inputData=l1.output.reshape( (batchsize, kernels[1] * 11 * 8)), numIn=kernels[1] * 11 * 8, numOut=2000, activation=T.tanh, rng=rng) l3 = CNN.LogisticRegression(inputData=l2.output, numIn=2000, numOut=40) cost = l3.logLikelihood(y) """ ================================================================================================================================ """ #Here I will give a brief introduction to how to build the model. #Using the given index, we can get the corresponding x and y(what given does). #Because l3.error() is applied, l2 - l1 - l0 were also applied. i.e. CNN is applied #In this way, model was built. testModel = theano.function( [index], l3.error(y), givens={ x: testX[index * batchsize:(index + 1) * batchsize], y: testY[index * batchsize:(index + 1) * batchsize] }) validationModel = theano.function( [index], l3.error(y), givens={ x: validX[index * batchsize:(index + 1) * batchsize], y: validY[index * batchsize:(index + 1) * batchsize] }) #SGD(stochastic gradient decent) parameters = l0.parameters + l1.parameters + l2.parameters + l3.parameters grads = T.grad(cost, parameters) updates = [(p, p - learningRate * g) for p, g in zip(parameters, grads)] trainingModel = theano.function( [index], cost, updates=updates, givens={ x: trainX[index * batchsize:(index + 1) * batchsize], y: trainY[index * batchsize:(index + 1) * batchsize] }) """ ================================================================================================================================= """ print 'training' ptc = 800 ptcInc = 2 threshold = 0.99 #To ensure that always validate on validation data validationFrequency = min(numTrainBatches, ptc / 2) bstValidationL = numpy.inf bstIter = 0 start = time.clock() epoch = 0 done = False #Now it's time to train, really tricky. #Kind of like SVM, a epoch will go through all data set. For each while loop, we need to train #each batch by using the for loop. If the current loss is less than the best validation loss #we will update them, and if the current loss is less than the threshold x best validation loss #we will update the patience. while (epoch < epochs) and (not done): epoch += 1 for ind in xrange(numTrainBatches): iter = (epoch - 1) * numTrainBatches + ind c = trainingModel(ind) if (iter + 1) % validationFrequency == 0: validationL = [ validationModel(i) for i in xrange(numValidBatches) ] currentL = numpy.mean(validationL) #print('epoch %i, validation error %f %%' % (epoch, currentL * 100.0)) if currentL < bstValidationL: if currentL < bstValidationL * threshold: ptc = max(ptc, iter * ptcInc) bstValidationL = currentL bstIter = iter load_save_data.saveData(l0.parameters, l1.parameters, l2.parameters, l3.parameters) testL = [testModel(i) for i in xrange(numTestBatches)] tstscore = numpy.mean(testL) print(('epoch %i, model error: %f %%') % (epoch, tstscore * 100.0)) if ptc <= iter: done = True break end = time.clock() print('Optimization: ') print('validation score: %f %% iter: %i' % (bstValidationL * 100.0, bstIter + 1)) print('time: %.2f ' % (end - start))
def cnn_mnist(dataset): learning_rate = 0.1 n_epochs = 200 batch_size = 500 #nkerns : number of kernels on each layer nkerns = [20, 10] train_set_x, train_set_y = dataset[0] valid_set_x, valid_set_y = dataset[1] test_set_x, test_set_y = dataset[2] n_train_batches = train_set_x.get_value(borrow=True).shape[0] // batch_size n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] // batch_size n_test_batches = test_set_x.get_value(borrow=True).shape[0] // batch_size index = T.lscalar() x = T.matrix('x') y = T.ivector('y') print('Building the model...') layer0_input = x.reshape((batch_size, 1, 28, 28)) layer0 = CNN.ConvPoolLayer(rng, input=layer0_input, image_shape=(batch_size, 1, 28, 28), filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2)) layer1 = CNN.ConvPoolLayer(rng, input=layer0.output, image_shape=(batch_size, nkerns[0], 12, 12), filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2)) layer2_input = layer1.output.flatten(2) layer2 = MultiLayerPerceptron.HiddenLayer(rng, input=layer2_input, n_in=nkerns[1] * 4 * 4, n_out=80, activation=T.tanh) layer3 = LogisticRegression.LogisticRegression(input=layer2.output, n_in=80, n_out=10) cost = layer3.NLL(y) 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] }) print('1. Test built.') 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] }) print('2. Valid built.') params = layer3.params + layer2.params + layer1.params + layer0.params grads = T.grad(cost, params) updates = [(param_i, param_i - learning_rate * grad_i) for param_i, grad_i in zip(params, grads)] print('3. Derivative calculated.') 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] }) print('4. Train built.') print('Train model...') patience = 10000 patience_increase = 2 improvement_threshold = 0.995 validation_frequency = min(n_train_batches, patience // 2) 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: 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 %.2f %%' % (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100)) if this_validation_loss < best_validation_loss: 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_losses = [ test_model(i) for i in range(n_test_batches) ] test_score = numpy.mean(test_losses) print( '\tepoch %i, minibatch %i/%i, test error of best model %.2f %%' % (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 %.2f %%' % (best_validation_loss * 100, best_iter + 1, test_score * 100))