def main(argv=None): dataset = load_data() model = create_model() # Restore previously trained model weights (if they exist) chkpt = tf.train.latest_checkpoint(CHECKPOINT_DIR) if chkpt: model.load_weights(chkpt) else: raise RuntimeError('Predictions require a trained model!') test_images = dataset['test'].images[0:10] test_labels = dataset['test'].labels[0:10] predictions = (model.predict(test_images) > 0.8).astype(int) print(predictions) print(test_labels.astype(int)) cleanup()
def test_dcca(learning_rate=0.01, L1_reg=0.0001, L2_reg=0.0001, n_epochs=1000, dataset='mnist.pkl.gz', batch_size=20, n_hidden=500): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :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: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ 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] / 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 ###################### # BUILD ACTUAL MODEL # ###################### print '... building the model' # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch x1 = T.matrix('x1') # the data is presented as rasterized images x2 = T.matrix('x2') # the labels are presented as 1D vector of # [int] labels h1 = T.matrix('h1') # the data is presented as rasterized images h2 = T.matrix('h2') # the labels are presented as 1D vector of rng = numpy.random.RandomState(1234) # construct the MLP class net1 = DCCA(rng=rng, input=x1, n_in=28 * 28, n_hidden=300, n_out=8) net2 = DCCA(rng=rng, input=x2, n_in=10, n_hidden=20, n_out=8) if 1: cost1 = (net1.correlation(h1, h2) + L1_reg * net1.L1 + L2_reg * net1.L2_sqr) cost2 = (net2.correlation(h1, h2) + L1_reg * net2.L1 + L2_reg * net2.L2_sqr) """ test_model = theano.function( inputs=[index], outputs=net1.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] } ) """ fprop_model1 = theano.function(inputs=[], outputs=(net1.hiddenLayer.output, net1.output), givens={x1: test_set_x}) fprop_model2 = theano.function(inputs=[], outputs=(net2.hiddenLayer.output, net2.output), givens={x2: test_set_y}) if 1: # grad compute for net1 in theano U, V, D = theano.tensor.nlinalg.svd(net1.lastLayer.Tval) UVT = T.dot(U, V.T) Delta12 = T.dot(net1.lastLayer.SigmaHat11**(-0.5), T.dot(UVT, net1.lastLayer.SigmaHat22**(-0.5))) UDUT = T.dot(U, T.dot(D, U.T)) Delta11 = (-0.5) * T.dot( net1.lastLayer.SigmaHat11**(-0.5), T.dot(UDUT, net1.lastLayer.SigmaHat22**(-0.5))) grad_E_to_o = (1.0 / 8) * (2 * Delta11 * net1.lastLayer.H1bar + Delta12 * net1.lastLayer.H2bar) gparam1_W = (grad_E_to_o) * (net1.lastLayer.output * (1 - net1.lastLayer.output)) * ( net1.hiddenLayer.output) gparam1_b = (grad_E_to_o) * ( net1.lastLayer.output * (1 - net1.lastLayer.output)) * theano.shared( numpy.array([1.0], dtype=theano.config.floatX), borrow=True) #gparams1 = [T.grad(cost1, param) for param in net1.params] gparams1 = [T.grad(cost1, param) for param in net1.hiddenLayer.params] gparams1.append(gparam1_W) #gparams1.append(gparam1_b) if 1: # grad compute for net2 U, V, D = theano.tensor.nlinalg.svd(net2.lastLayer.Tval) UVT = T.dot(U, V.T) Delta12 = T.dot(net2.lastLayer.SigmaHat11**(-0.5), T.dot(UVT, net2.lastLayer.SigmaHat22**(-0.5))) UDUT = T.dot(U, T.dot(D, U.T)) Delta11 = (-0.5) * T.dot(net2.lastLayer.SigmaHat11**(-0.5), T.dot(UVT, net2.lastLayer.SigmaHat22**(-0.5))) grad_E_to_o = (1.0 / 8) * (2 * Delta11 * net2.lastLayer.H1bar + Delta12 * net2.lastLayer.H2bar) gparam2_W = (grad_E_to_o) * (net2.lastLayer.output * (1 - net2.lastLayer.output)) * ( net2.hiddenLayer.output) gparam2_b = (grad_E_to_o) * (net2.lastLayer.output * (1 - net2.lastLayer.output)) * 1 #gparams1 = [T.grad(cost1, param) for param in net1.params] gparams2 = [T.grad(cost2, param) for param in net2.hiddenLayer.params] gparams2.append(gparam2_W) gparams2.append(gparam2_b) #gparams2 = [T.grad(cost2, param) for param in net2.params] updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net1.params, gparams1)] updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net2.params, gparams2)] ############### # 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 = time.clock() epoch = 0 done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 print 'epoch', epoch #net1.fprop(test_set_x) #net2.fprop(test_set_y) h1hidden, h1tmpval = fprop_model1() h2hidden, h2tmpval = fprop_model2() h1hidden = h1hidden.T h2hidden = h2hidden.T h1tmpval = h1tmpval.T h2tmpval = h2tmpval.T if 1: # compute cost(H1, H2) H1 = h1tmpval H2 = h2tmpval m = H1.shape[1] H1bar = H1 - (1.0 / m) * numpy.dot( H1, numpy.ones((m, m), dtype=numpy.float32)) H2bar = H2 - (1.0 / m) * numpy.dot( H2, numpy.ones((m, m), dtype=numpy.float32)) SigmaHat12 = (1.0 / (m - 1)) * numpy.dot(H1bar, H2bar.T) SigmaHat11 = (1.0 / (m - 1)) * numpy.dot(H1bar, H1bar.T) SigmaHat11 = SigmaHat11 + 0.0001 * numpy.identity( SigmaHat11.shape[0], dtype=numpy.float32) SigmaHat22 = (1.0 / (m - 1)) * numpy.dot(H2bar, H2bar.T) SigmaHat22 = SigmaHat22 + 0.0001 * numpy.identity( SigmaHat22.shape[0], dtype=numpy.float32) Tval = numpy.dot(mat_pow(SigmaHat11), numpy.dot(SigmaHat12, mat_pow(SigmaHat22))) corr = numpy.trace(numpy.dot(Tval.T, Tval))**(0.5) if 1: # compute gradient dcost(H1,H2)/dH1 U, D, V, = numpy.linalg.svd(Tval) UVT = numpy.dot(U, V.T) Delta12 = numpy.dot(mat_pow(SigmaHat11), numpy.dot(UVT, mat_pow(SigmaHat22))) UDUT = numpy.dot(U, numpy.dot(D, U.T)) Delta11 = (-0.5) * numpy.dot(mat_pow(SigmaHat11), numpy.dot(UDUT, mat_pow(SigmaHat22))) grad_E_to_o = (1.0 / m) * (2 * numpy.dot(Delta11, H1bar) + numpy.dot(Delta12, H2bar)) ##gparam1_W = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * (h1hidden) gparam1_W = numpy.dot( (h1hidden), ((grad_E_to_o) * (h1tmpval * (1 - h1tmpval))).T) ##gparam1_b = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * theano.shared(numpy.array([1.0],dtype=theano.config.floatX), borrow=True) gparam1_b = numpy.dot( numpy.ones((1, 10000), dtype=theano.config.floatX), ((grad_E_to_o) * (h1tmpval * (1 - h1tmpval))).T) gparam1_W = theano.shared(gparam1_W, borrow=True) gparam1_b = theano.shared(gparam1_b[0, :], borrow=True) #gparams1 = [T.grad(cost1, param) for param in net1.params] gparams1 = [ T.grad(cost1, param) for param in net1.hiddenLayer.params ] gparams1.append(gparam1_W) updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net1.params, gparams1)] #gparams1.append(gparam1_b) if 1: # compute gradient dcost(H1,H2)/dH2 Tval2 = numpy.dot(mat_pow(SigmaHat22), numpy.dot(SigmaHat12.T, mat_pow(SigmaHat11))) U, D, V, = numpy.linalg.svd(Tval2) UVT = numpy.dot(U, V.T) Delta12 = numpy.dot(mat_pow(SigmaHat22), numpy.dot(UVT, mat_pow(SigmaHat11))) UDUT = numpy.dot(U, numpy.dot(D, U.T)) Delta11 = (-0.5) * numpy.dot(mat_pow(SigmaHat22), numpy.dot(UDUT, mat_pow(SigmaHat11))) grad_E_to_o = (1.0 / m) * (2 * numpy.dot(Delta11, H2bar) + numpy.dot(Delta12, H1bar)) ##gparam1_W = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * (h1hidden) gparam2_W = numpy.dot( (h2hidden), ((grad_E_to_o) * (h2tmpval * (1 - h2tmpval))).T) ##gparam1_b = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * theano.shared(numpy.array([1.0],dtype=theano.config.floatX), borrow=True) gparam2_b = numpy.dot( numpy.ones((1, 10000), dtype=theano.config.floatX), ((grad_E_to_o) * (h2tmpval * (1 - h2tmpval))).T) gparam2_W = theano.shared(gparam2_W, borrow=True) gparam2_b = theano.shared(gparam2_b[0, :], borrow=True) #gparams1 = [T.grad(cost1, param) for param in net1.params] gparams2 = [ T.grad(cost2, param) for param in net2.hiddenLayer.params ] gparams2.append(gparam2_W) updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net2.params, gparams2)] #gparams1.append(gparam1_b) #X_theano = theano.shared(value=X, name='inputs') #h1tmp = theano.shared( value=h1tmpval, name='hidden1_rep', dtype=theano.config.floatX , borrow=True) h1tmp = theano.shared(numpy.asarray(H1bar, dtype=theano.config.floatX), borrow=True) #h2tmp = theano.shared( value=h2tmpval, name='hidden2_rep', dtype=theano.config.floatX , borrow=True) h2tmp = theano.shared(numpy.asarray(H2bar, dtype=theano.config.floatX), borrow=True) #h1tmp = T.shared( value=net1.output.eval(), name='hidden1_rep' ) #h2tmp = T.shared( net2.output.eval() ) train_model1 = theano.function( inputs=[], #outputs=cost1, updates=updates1, givens={ #x1: test_set_x, h1: h1tmp, h2: h2tmp }) train_model2 = theano.function( inputs=[], #outputs=cost2, updates=updates2, givens={ #x2: test_set_y, h1: h1tmp, h2: h2tmp }) minibatch_avg_cost1 = train_model1() minibatch_avg_cost2 = train_model2() #print 'corr1', minibatch_avg_cost1 #print 'corr2', minibatch_avg_cost2 print 'corr', corr if epoch > 10: break end_time = time.clock() 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 >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)) ''' Loads the dataset :type dataset: string :param dataset: the path to the dataset (here MNIST) ''' ############# # LOAD DATA # ############# # Download the MNIST dataset if it is not present data_dir, data_file = os.path.split(dataset) if data_dir == "" and not os.path.isfile(dataset): # Check if dataset is in the data directory. new_path = os.path.join( os.path.split(__file__)[0], "..", "data", dataset) if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz': dataset = new_path if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz': import urllib origin = ( 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz') print 'Downloading data from %s' % origin urllib.urlretrieve(origin, dataset) print '... loading data' # Load the dataset f = gzip.open(dataset, 'rb') train_set, valid_set, test_set = cPickle.load(f) f.close() #train_set, valid_set, test_set format: tuple(input, target) #input is an numpy.ndarray of 2 dimensions (a matrix) #witch row's correspond to an example. target is a #numpy.ndarray of 1 dimensions (vector)) that have the same length as #the number of rows in the input. It should give the target #target to the example with the same index in the input. def shared_dataset(data_xy, borrow=True): """ Function that loads the dataset into shared variables The reason we store our dataset in shared variables is to allow Theano to copy it into the GPU memory (when code is run on GPU). Since copying data into the GPU is slow, copying a minibatch everytime is needed (the default behaviour if the data is not in a shared variable) would lead to a large decrease in performance. """ #import copy data_x, data_y = data_xy #daya_y = copy.deepcopy(data_x) data_y_new = numpy.zeros((data_y.shape[0], data_y.max() + 1)) for i in range(data_y.shape[0]): data_y_new[i, data_y[i]] = 1 data_y = data_y_new shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, dtype=theano.config.floatX), borrow=borrow) # When storing data on the GPU it has to be stored as floats # therefore we will store the labels as ``floatX`` as well # (``shared_y`` does exactly that). But during our computations # we need them as ints (we use labels as index, and if they are # floats it doesn't make sense) therefore instead of returning # ``shared_y`` we will have to cast it to int. This little hack # lets ous get around this issue return shared_x, shared_y test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval
def test_dcca_old(learning_rate=0.01, L1_reg=0.0001, L2_reg=0.0001, n_epochs=1000, dataset='mnist.pkl.gz', batch_size=20, n_hidden=500): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :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: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ 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] / 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 ###################### # 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') # the data is presented as rasterized images y = T.matrix('y') # the labels are presented as 1D vector of # [int] labels rng = numpy.random.RandomState(1234) # construct the MLP class if 0: net1 = MLP(rng=rng, input=x, n_in=28 * 28, n_hidden=300, n_out=50) net2 = MLP(rng=rng, input=y, n_in=10, n_hidden=20, n_out=5) net = DCCA(rng=rng, x1=x, x2=y, n_in1=28 * 28, n_hidden1=300, n_out1=50, n_in2=10, n_hidden2=20, n_out2=5) # start-snippet-4 # 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 cost1 = (net.correlation(y) + L1_reg * net.L11 + L2_reg * net.L2_sqr1) cost2 = (net.correlation(y) + L1_reg * net.L12 + L2_reg * net.L2_sqr2) # end-snippet-4 # compiling a Theano function that computes the mistakes that are made # by the model on a minibatch """ test_model = theano.function( inputs=[index], outputs=net1.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] } ) """ # start-snippet-5 # compute the gradient of cost with respect to theta (sotred in params) # the resulting gradients will be stored in a list gparams gparams1 = [T.grad(cost1, param) for param in net.params1] gparams2 = [T.grad(cost2, param) for param in net.params2] # specify how to update the parameters of the model as a list of # (variable, update expression) pairs # given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of # same length, 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)] updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net.params1, gparams1)] updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net.params2, gparams2)] # 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_model1 = theano.function( inputs=[index], outputs=cost1, updates=updates1, givens={ x: train_set_x[index * batch_size:(index + 1) * batch_size], y: train_set_y[index * batch_size:(index + 1) * batch_size] }) train_model2 = theano.function( inputs=[index], outputs=cost2, updates=updates2, 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-5 ############### # 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 = time.clock() epoch = 0 done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 for minibatch_index in xrange(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 xrange(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 xrange(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 = time.clock() 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 >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)) ''' Loads the dataset :type dataset: string :param dataset: the path to the dataset (here MNIST) ''' ############# # LOAD DATA # ############# # Download the MNIST dataset if it is not present data_dir, data_file = os.path.split(dataset) if data_dir == "" and not os.path.isfile(dataset): # Check if dataset is in the data directory. new_path = os.path.join( os.path.split(__file__)[0], "..", "data", dataset) if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz': dataset = new_path if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz': import urllib origin = ( 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz') print 'Downloading data from %s' % origin urllib.urlretrieve(origin, dataset) print '... loading data' # Load the dataset f = gzip.open(dataset, 'rb') train_set, valid_set, test_set = cPickle.load(f) f.close() #train_set, valid_set, test_set format: tuple(input, target) #input is an numpy.ndarray of 2 dimensions (a matrix) #witch row's correspond to an example. target is a #numpy.ndarray of 1 dimensions (vector)) that have the same length as #the number of rows in the input. It should give the target #target to the example with the same index in the input. def shared_dataset(data_xy, borrow=True): """ Function that loads the dataset into shared variables The reason we store our dataset in shared variables is to allow Theano to copy it into the GPU memory (when code is run on GPU). Since copying data into the GPU is slow, copying a minibatch everytime is needed (the default behaviour if the data is not in a shared variable) would lead to a large decrease in performance. """ #import copy data_x, data_y = data_xy #daya_y = copy.deepcopy(data_x) data_y_new = numpy.zeros((data_y.shape[0], data_y.max() + 1)) for i in range(data_y.shape[0]): data_y_new[i, data_y[i]] = 1 data_y = data_y_new shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, dtype=theano.config.floatX), borrow=borrow) # When storing data on the GPU it has to be stored as floats # therefore we will store the labels as ``floatX`` as well # (``shared_y`` does exactly that). But during our computations # we need them as ints (we use labels as index, and if they are # floats it doesn't make sense) therefore instead of returning # ``shared_y`` we will have to cast it to int. This little hack # lets ous get around this issue return shared_x, shared_y test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval
def test_dcca( learning_rate=0.01, L1_reg=0.0001, L2_reg=0.0001, n_epochs=1000, dataset="mnist.pkl.gz", batch_size=20, n_hidden=500 ): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :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: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ 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] / 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 ###################### # BUILD ACTUAL MODEL # ###################### print "... building the model" # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch x1 = T.matrix("x1") # the data is presented as rasterized images x2 = T.matrix("x2") # the labels are presented as 1D vector of # [int] labels h1 = T.matrix("h1") # the data is presented as rasterized images h2 = T.matrix("h2") # the labels are presented as 1D vector of rng = numpy.random.RandomState(1234) # construct the MLP class net1 = DCCA(rng=rng, input=x1, n_in=28 * 28, n_hidden=300, n_out=8) net2 = DCCA(rng=rng, input=x2, n_in=10, n_hidden=20, n_out=8) if 1: cost1 = net1.correlation(h1, h2) + L1_reg * net1.L1 + L2_reg * net1.L2_sqr cost2 = net2.correlation(h1, h2) + L1_reg * net2.L1 + L2_reg * net2.L2_sqr """ test_model = theano.function( inputs=[index], outputs=net1.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] } ) """ fprop_model1 = theano.function(inputs=[], outputs=(net1.hiddenLayer.output, net1.output), givens={x1: test_set_x}) fprop_model2 = theano.function(inputs=[], outputs=(net2.hiddenLayer.output, net2.output), givens={x2: test_set_y}) if 1: # grad compute for net1 in theano U, V, D = theano.tensor.nlinalg.svd(net1.lastLayer.Tval) UVT = T.dot(U, V.T) Delta12 = T.dot(net1.lastLayer.SigmaHat11 ** (-0.5), T.dot(UVT, net1.lastLayer.SigmaHat22 ** (-0.5))) UDUT = T.dot(U, T.dot(D, U.T)) Delta11 = (-0.5) * T.dot(net1.lastLayer.SigmaHat11 ** (-0.5), T.dot(UDUT, net1.lastLayer.SigmaHat22 ** (-0.5))) grad_E_to_o = (1.0 / 8) * (2 * Delta11 * net1.lastLayer.H1bar + Delta12 * net1.lastLayer.H2bar) gparam1_W = (grad_E_to_o) * (net1.lastLayer.output * (1 - net1.lastLayer.output)) * (net1.hiddenLayer.output) gparam1_b = ( (grad_E_to_o) * (net1.lastLayer.output * (1 - net1.lastLayer.output)) * theano.shared(numpy.array([1.0], dtype=theano.config.floatX), borrow=True) ) # gparams1 = [T.grad(cost1, param) for param in net1.params] gparams1 = [T.grad(cost1, param) for param in net1.hiddenLayer.params] gparams1.append(gparam1_W) # gparams1.append(gparam1_b) if 1: # grad compute for net2 U, V, D = theano.tensor.nlinalg.svd(net2.lastLayer.Tval) UVT = T.dot(U, V.T) Delta12 = T.dot(net2.lastLayer.SigmaHat11 ** (-0.5), T.dot(UVT, net2.lastLayer.SigmaHat22 ** (-0.5))) UDUT = T.dot(U, T.dot(D, U.T)) Delta11 = (-0.5) * T.dot(net2.lastLayer.SigmaHat11 ** (-0.5), T.dot(UVT, net2.lastLayer.SigmaHat22 ** (-0.5))) grad_E_to_o = (1.0 / 8) * (2 * Delta11 * net2.lastLayer.H1bar + Delta12 * net2.lastLayer.H2bar) gparam2_W = (grad_E_to_o) * (net2.lastLayer.output * (1 - net2.lastLayer.output)) * (net2.hiddenLayer.output) gparam2_b = (grad_E_to_o) * (net2.lastLayer.output * (1 - net2.lastLayer.output)) * 1 # gparams1 = [T.grad(cost1, param) for param in net1.params] gparams2 = [T.grad(cost2, param) for param in net2.hiddenLayer.params] gparams2.append(gparam2_W) gparams2.append(gparam2_b) # gparams2 = [T.grad(cost2, param) for param in net2.params] updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net1.params, gparams1)] updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net2.params, gparams2)] ############### # 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.0 start_time = time.clock() epoch = 0 done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 print "epoch", epoch # net1.fprop(test_set_x) # net2.fprop(test_set_y) h1hidden, h1tmpval = fprop_model1() h2hidden, h2tmpval = fprop_model2() h1hidden = h1hidden.T h2hidden = h2hidden.T h1tmpval = h1tmpval.T h2tmpval = h2tmpval.T if 1: # compute cost(H1, H2) H1 = h1tmpval H2 = h2tmpval m = H1.shape[1] H1bar = H1 - (1.0 / m) * numpy.dot(H1, numpy.ones((m, m), dtype=numpy.float32)) H2bar = H2 - (1.0 / m) * numpy.dot(H2, numpy.ones((m, m), dtype=numpy.float32)) SigmaHat12 = (1.0 / (m - 1)) * numpy.dot(H1bar, H2bar.T) SigmaHat11 = (1.0 / (m - 1)) * numpy.dot(H1bar, H1bar.T) SigmaHat11 = SigmaHat11 + 0.0001 * numpy.identity(SigmaHat11.shape[0], dtype=numpy.float32) SigmaHat22 = (1.0 / (m - 1)) * numpy.dot(H2bar, H2bar.T) SigmaHat22 = SigmaHat22 + 0.0001 * numpy.identity(SigmaHat22.shape[0], dtype=numpy.float32) Tval = numpy.dot(mat_pow(SigmaHat11), numpy.dot(SigmaHat12, mat_pow(SigmaHat22))) corr = numpy.trace(numpy.dot(Tval.T, Tval)) ** (0.5) if 1: # compute gradient dcost(H1,H2)/dH1 U, D, V, = numpy.linalg.svd(Tval) UVT = numpy.dot(U, V.T) Delta12 = numpy.dot(mat_pow(SigmaHat11), numpy.dot(UVT, mat_pow(SigmaHat22))) UDUT = numpy.dot(U, numpy.dot(D, U.T)) Delta11 = (-0.5) * numpy.dot(mat_pow(SigmaHat11), numpy.dot(UDUT, mat_pow(SigmaHat22))) grad_E_to_o = (1.0 / m) * (2 * numpy.dot(Delta11, H1bar) + numpy.dot(Delta12, H2bar)) ##gparam1_W = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * (h1hidden) gparam1_W = numpy.dot((h1hidden), ((grad_E_to_o) * (h1tmpval * (1 - h1tmpval))).T) ##gparam1_b = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * theano.shared(numpy.array([1.0],dtype=theano.config.floatX), borrow=True) gparam1_b = numpy.dot( numpy.ones((1, 10000), dtype=theano.config.floatX), ((grad_E_to_o) * (h1tmpval * (1 - h1tmpval))).T ) gparam1_W = theano.shared(gparam1_W, borrow=True) gparam1_b = theano.shared(gparam1_b[0, :], borrow=True) # gparams1 = [T.grad(cost1, param) for param in net1.params] gparams1 = [T.grad(cost1, param) for param in net1.hiddenLayer.params] gparams1.append(gparam1_W) updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net1.params, gparams1)] # gparams1.append(gparam1_b) if 1: # compute gradient dcost(H1,H2)/dH2 Tval2 = numpy.dot(mat_pow(SigmaHat22), numpy.dot(SigmaHat12.T, mat_pow(SigmaHat11))) U, D, V, = numpy.linalg.svd(Tval2) UVT = numpy.dot(U, V.T) Delta12 = numpy.dot(mat_pow(SigmaHat22), numpy.dot(UVT, mat_pow(SigmaHat11))) UDUT = numpy.dot(U, numpy.dot(D, U.T)) Delta11 = (-0.5) * numpy.dot(mat_pow(SigmaHat22), numpy.dot(UDUT, mat_pow(SigmaHat11))) grad_E_to_o = (1.0 / m) * (2 * numpy.dot(Delta11, H2bar) + numpy.dot(Delta12, H1bar)) ##gparam1_W = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * (h1hidden) gparam2_W = numpy.dot((h2hidden), ((grad_E_to_o) * (h2tmpval * (1 - h2tmpval))).T) ##gparam1_b = (grad_E_to_o) * (h1tmpval*(1-h1tmpval)) * theano.shared(numpy.array([1.0],dtype=theano.config.floatX), borrow=True) gparam2_b = numpy.dot( numpy.ones((1, 10000), dtype=theano.config.floatX), ((grad_E_to_o) * (h2tmpval * (1 - h2tmpval))).T ) gparam2_W = theano.shared(gparam2_W, borrow=True) gparam2_b = theano.shared(gparam2_b[0, :], borrow=True) # gparams1 = [T.grad(cost1, param) for param in net1.params] gparams2 = [T.grad(cost2, param) for param in net2.hiddenLayer.params] gparams2.append(gparam2_W) updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net2.params, gparams2)] # gparams1.append(gparam1_b) # X_theano = theano.shared(value=X, name='inputs') # h1tmp = theano.shared( value=h1tmpval, name='hidden1_rep', dtype=theano.config.floatX , borrow=True) h1tmp = theano.shared(numpy.asarray(H1bar, dtype=theano.config.floatX), borrow=True) # h2tmp = theano.shared( value=h2tmpval, name='hidden2_rep', dtype=theano.config.floatX , borrow=True) h2tmp = theano.shared(numpy.asarray(H2bar, dtype=theano.config.floatX), borrow=True) # h1tmp = T.shared( value=net1.output.eval(), name='hidden1_rep' ) # h2tmp = T.shared( net2.output.eval() ) train_model1 = theano.function( inputs=[], # outputs=cost1, updates=updates1, givens={ # x1: test_set_x, h1: h1tmp, h2: h2tmp, }, ) train_model2 = theano.function( inputs=[], # outputs=cost2, updates=updates2, givens={ # x2: test_set_y, h1: h1tmp, h2: h2tmp, }, ) minibatch_avg_cost1 = train_model1() minibatch_avg_cost2 = train_model2() # print 'corr1', minibatch_avg_cost1 # print 'corr2', minibatch_avg_cost2 print "corr", corr if epoch > 10: break end_time = time.clock() print ( ( "Optimization complete. Best validation score of %f %% " "obtained at iteration %i, with test performance %f %%" ) % (best_validation_loss * 100.0, best_iter + 1, test_score * 100.0) ) print >> sys.stderr, ( "The code for file " + os.path.split(__file__)[1] + " ran for %.2fm" % ((end_time - start_time) / 60.0) ) """ Loads the dataset :type dataset: string :param dataset: the path to the dataset (here MNIST) """ ############# # LOAD DATA # ############# # Download the MNIST dataset if it is not present data_dir, data_file = os.path.split(dataset) if data_dir == "" and not os.path.isfile(dataset): # Check if dataset is in the data directory. new_path = os.path.join(os.path.split(__file__)[0], "..", "data", dataset) if os.path.isfile(new_path) or data_file == "mnist.pkl.gz": dataset = new_path if (not os.path.isfile(dataset)) and data_file == "mnist.pkl.gz": import urllib origin = "http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz" print "Downloading data from %s" % origin urllib.urlretrieve(origin, dataset) print "... loading data" # Load the dataset f = gzip.open(dataset, "rb") train_set, valid_set, test_set = cPickle.load(f) f.close() # train_set, valid_set, test_set format: tuple(input, target) # input is an numpy.ndarray of 2 dimensions (a matrix) # witch row's correspond to an example. target is a # numpy.ndarray of 1 dimensions (vector)) that have the same length as # the number of rows in the input. It should give the target # target to the example with the same index in the input. def shared_dataset(data_xy, borrow=True): """ Function that loads the dataset into shared variables The reason we store our dataset in shared variables is to allow Theano to copy it into the GPU memory (when code is run on GPU). Since copying data into the GPU is slow, copying a minibatch everytime is needed (the default behaviour if the data is not in a shared variable) would lead to a large decrease in performance. """ # import copy data_x, data_y = data_xy # daya_y = copy.deepcopy(data_x) data_y_new = numpy.zeros((data_y.shape[0], data_y.max() + 1)) for i in range(data_y.shape[0]): data_y_new[i, data_y[i]] = 1 data_y = data_y_new shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, dtype=theano.config.floatX), borrow=borrow) # When storing data on the GPU it has to be stored as floats # therefore we will store the labels as ``floatX`` as well # (``shared_y`` does exactly that). But during our computations # we need them as ints (we use labels as index, and if they are # floats it doesn't make sense) therefore instead of returning # ``shared_y`` we will have to cast it to int. This little hack # lets ous get around this issue return shared_x, shared_y test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval
def test_dcca_old( learning_rate=0.01, L1_reg=0.0001, L2_reg=0.0001, n_epochs=1000, dataset="mnist.pkl.gz", batch_size=20, n_hidden=500 ): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :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: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ 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] / 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 ###################### # 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") # the data is presented as rasterized images y = T.matrix("y") # the labels are presented as 1D vector of # [int] labels rng = numpy.random.RandomState(1234) # construct the MLP class if 0: net1 = MLP(rng=rng, input=x, n_in=28 * 28, n_hidden=300, n_out=50) net2 = MLP(rng=rng, input=y, n_in=10, n_hidden=20, n_out=5) net = DCCA(rng=rng, x1=x, x2=y, n_in1=28 * 28, n_hidden1=300, n_out1=50, n_in2=10, n_hidden2=20, n_out2=5) # start-snippet-4 # 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 cost1 = net.correlation(y) + L1_reg * net.L11 + L2_reg * net.L2_sqr1 cost2 = net.correlation(y) + L1_reg * net.L12 + L2_reg * net.L2_sqr2 # end-snippet-4 # compiling a Theano function that computes the mistakes that are made # by the model on a minibatch """ test_model = theano.function( inputs=[index], outputs=net1.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] } ) """ # start-snippet-5 # compute the gradient of cost with respect to theta (sotred in params) # the resulting gradients will be stored in a list gparams gparams1 = [T.grad(cost1, param) for param in net.params1] gparams2 = [T.grad(cost2, param) for param in net.params2] # specify how to update the parameters of the model as a list of # (variable, update expression) pairs # given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of # same length, 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)] updates1 = [(param, param - learning_rate * gparam) for param, gparam in zip(net.params1, gparams1)] updates2 = [(param, param - learning_rate * gparam) for param, gparam in zip(net.params2, gparams2)] # 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_model1 = theano.function( inputs=[index], outputs=cost1, updates=updates1, givens={ x: train_set_x[index * batch_size : (index + 1) * batch_size], y: train_set_y[index * batch_size : (index + 1) * batch_size], }, ) train_model2 = theano.function( inputs=[index], outputs=cost2, updates=updates2, 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-5 ############### # 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.0 start_time = time.clock() epoch = 0 done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 for minibatch_index in xrange(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 xrange(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.0) ) # 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 xrange(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.0) ) if patience <= iter: done_looping = True break end_time = time.clock() print ( ( "Optimization complete. Best validation score of %f %% " "obtained at iteration %i, with test performance %f %%" ) % (best_validation_loss * 100.0, best_iter + 1, test_score * 100.0) ) print >> sys.stderr, ( "The code for file " + os.path.split(__file__)[1] + " ran for %.2fm" % ((end_time - start_time) / 60.0) ) """ Loads the dataset :type dataset: string :param dataset: the path to the dataset (here MNIST) """ ############# # LOAD DATA # ############# # Download the MNIST dataset if it is not present data_dir, data_file = os.path.split(dataset) if data_dir == "" and not os.path.isfile(dataset): # Check if dataset is in the data directory. new_path = os.path.join(os.path.split(__file__)[0], "..", "data", dataset) if os.path.isfile(new_path) or data_file == "mnist.pkl.gz": dataset = new_path if (not os.path.isfile(dataset)) and data_file == "mnist.pkl.gz": import urllib origin = "http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz" print "Downloading data from %s" % origin urllib.urlretrieve(origin, dataset) print "... loading data" # Load the dataset f = gzip.open(dataset, "rb") train_set, valid_set, test_set = cPickle.load(f) f.close() # train_set, valid_set, test_set format: tuple(input, target) # input is an numpy.ndarray of 2 dimensions (a matrix) # witch row's correspond to an example. target is a # numpy.ndarray of 1 dimensions (vector)) that have the same length as # the number of rows in the input. It should give the target # target to the example with the same index in the input. def shared_dataset(data_xy, borrow=True): """ Function that loads the dataset into shared variables The reason we store our dataset in shared variables is to allow Theano to copy it into the GPU memory (when code is run on GPU). Since copying data into the GPU is slow, copying a minibatch everytime is needed (the default behaviour if the data is not in a shared variable) would lead to a large decrease in performance. """ # import copy data_x, data_y = data_xy # daya_y = copy.deepcopy(data_x) data_y_new = numpy.zeros((data_y.shape[0], data_y.max() + 1)) for i in range(data_y.shape[0]): data_y_new[i, data_y[i]] = 1 data_y = data_y_new shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, dtype=theano.config.floatX), borrow=borrow) # When storing data on the GPU it has to be stored as floats # therefore we will store the labels as ``floatX`` as well # (``shared_y`` does exactly that). But during our computations # we need them as ints (we use labels as index, and if they are # floats it doesn't make sense) therefore instead of returning # ``shared_y`` we will have to cast it to int. This little hack # lets ous get around this issue return shared_x, shared_y test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batchsize', '-b', type=int, default=64, help='Number of images in each mini-batch') parser.add_argument('--unit', '-u', type=int, default=64, help='Number of units') parser.add_argument('--best-model', help='path to best model') args = parser.parse_args() DATA_DIR = '/baobab/kiyomaru/2018-shinjin/jumanpp.midasi' PATH_TO_TEST = os.path.join(DATA_DIR, 'test.csv') PATH_TO_WE = '/share/data/word2vec/2016.08.02/w2v.midasi.256.100K.bin' # load test data test_x, test_y = load_data(PATH_TO_TEST) word_vectors = KeyedVectors.load_word2vec_format(PATH_TO_WE, binary=True) word2index = {} for index, word in enumerate(word_vectors.index2word): word2index[word] = index # convert document to ids test_ids = assign_id_to_document(test_x, word2index) # convert test_y to numpy.array y_true = numpy.array(test_y) # define model model = MLP(n_vocab=len(word2index), n_embed=word_vectors.vector_size, n_units=args.unit, W=None) model = L.Classifier(model) # load pre-trained model try: chainer.serializers.load_npz(args.best_model, model) except Exception as e: print('error:', str(e)) sys.exit(1) # predict labels for test data with chainer.using_config('train', False): y_pred = [] for i in range(0, len(test_ids), args.batchsize): x = test_ids[i:i + args.batchsize] y = model.predictor(x) y_pred.append(F.argmax(y, axis=1).data[:, None]) y_pred = numpy.vstack(y_pred) # calculate macro-f1 print(f1_score(y_true, y_pred, average='macro')) print('\nClass\tPre\tRec\tF1\tSupport') for i, (p, r, f, s) in enumerate( zip(*precision_recall_fscore_support(y_true, y_pred))): print('%d\t%.4f\t%.4f\t%.4f\t%d' % (i, p, r, f, s)) print('\nConfusion matrix (row: true, column: prediction)') for pred in confusion_matrix(y_true, y_pred): print('\t'.join([str(p) for p in pred]) + '\t(Support: %d)' % sum(pred))
def evaluate_lenet5(learning_rate=0.1, n_epochs=200, dataset='mnist.pkl.gz', nkerns=[20, 50], batch_size=500): """ Demonstrates lenet on MNIST dataset 实验数据集是MNIST数据集。 :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 n_epochs是最大迭代次数。一次完整迭代包括计算完所有完整数据,即(总数size/batch_size)次 :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 卷积核数目。第一个下采样层有20个卷积核,第二个下采样有50个卷积核。 一个卷积核经过卷积计算会生成一张特征图。 (我认为卷积核就相当于神经元的个数,对应着权值的元素个数) """ # 下面这些和MLP中的都是一样的。 rng = numpy.random.RandomState(23455) 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 /= 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' # 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. # 构造第0层的输入数据。就是把shape为(batch_size,28*28)数据块转化为四维(batch_size,1,28,28) # ()batch_size,28*28)就是有batch_size行,一行对应一个样本,每行有28*28列,是对应样本的具体数据。 layer0_input = x.reshape((batch_size, 1, 28, 28)) # 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, 28, 28), filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2) ) # 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) layer1 = LeNetConvPoolLayer( rng, input=layer0.output, image_shape=(batch_size, nkerns[0], 12, 12), filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2) ) # 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] * 4 * 4, n_out=500, activation=T.tanh ) # classify the values of the fully-connected sigmoidal layer layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10) # 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 xrange(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 xrange(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 xrange(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.)) print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.))