theano测试代码

保存在这里,供大家参考

import six.moves.cPickle as pickleimport gzipimport osimport sysimport timeitimport numpyimport theanoimport theano.tensor as Tdef load_data(dataset):    with gzip.open(dataset, 'rb') as f:         try:            train_set, valid_set, test_set = pickle.load(f, encoding='latin1')         except:            train_set, valid_set, test_set = pickle.load(f)    def shared_dataset(data_xy, borrow = True):        data_x, data_y = data_xy        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)        return shared_x, T.cast(shared_y, 'int32')    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)    res = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)]    return resclass LogisticRegression(object):    def __init__(self, input, n_in, n_out):        self.w = theano.shared(value= numpy.zeros( (n_in, n_out), dtype = theano.config.floatX), name = 'w', borrow = True)        self.b = theano.shared(value= numpy.zeros( n_out, dtype = theano.config.floatX), name = 'b', borrow = True)        self.pyx = T.nnet.softmax(T.dot(input, self.w) + self.b )        self.y_pred = T.argmax(self.pyx, axis = 1)        self.params = [self.w, self.b]        self.input = input    def negative_log_likelihood(self, y):        return -T.mean( T.log(self.pyx)[T.arange(y.shape[0]), y] )    def errors(self, y):        if (y.ndim != self.y_pred.ndim):            raise TypeError(('y', y.type, 'y_pred', y_pred.type))        if y.dtype.startswith('int'):            return T.mean(T.neq(self.y_pred, y))        else:            raise NotImplementedError()def sgd_optimization_mnist(learning_rate = 0.13, n_epoches = 1000, dataset = 'mnist.pkl.gz', batch_size = 600):    data = load_data(dataset)    train_x, train_y = data[0]    valid_x, valid_y = data[1]    test_x, test_y = data[2]    n_train_batch = train_x.get_value(borrow=True).shape[0] // batch_size    n_valid_batch = valid_x.get_value(borrow=True).shape[0] // batch_size    n_test_batch = test_x.get_value(borrow=True).shape[0] // batch_size    x = T.matrix('x')    y = T.ivector('y')    index = T.lscalar()    classifier = LogisticRegression(input = x, n_in = 28*28, n_out = 10)    cost = classifier.negative_log_likelihood(y)    test_model = theano.function(        inputs = [index],        outputs = classifier.errors(y),        givens = {            x: test_x[index * batch_size: (index+1) * batch_size],            y: test_y[index * batch_size: (index+1) * batch_size]        }    )    valid_model = theano.function(        inputs = [index],        outputs = classifier.errors(y),        givens = {            x: valid_x[index * batch_size: (index+1) * batch_size],            y: valid_y[index * batch_size: (index+1) * batch_size]        }            )    g_w = T.grad(cost, classifier.w)    g_b = T.grad(cost, classifier.b)    updates = [(classifier.w, classifier.w - g_w * learning_rate),(classifier.b, classifier.b - g_b * learning_rate)]    train_model = theano.function(        inputs = [index],        outputs = cost,        updates = updates,          givens = {            x: train_x[index * batch_size: (index+1)*batch_size],            y: train_y[index * batch_size: (index+1)*batch_size]        }    )    best_validation_loss = numpy.inf    improvement_threshold = 0.995    epoch = 0    max_epoch = 100    start_time = timeit.default_timer()    while (epoch < max_epoch):        for minibatch_index in range(n_train_batch):            minibatch_cost = train_model(minibatch_index)        validation_loss_ary =  [valid_model(i) for i in range(n_valid_batch)]        validation_loss = numpy.mean(validation_loss_ary)        if(validation_loss < best_validation_loss ):            if(validation_loss < best_validation_loss * improvement_threshold):                max_epoch = max(max_epoch, epoch * 2)            best_validation_loss = validation_loss            with open('best_model.pkl', 'wb') as f:                pickle.dump(classifier, f)        print('epoch %i, now validation_loss is %f %%' % (epoch, validation_loss * 100.))        epoch+=1    end_time = timeit.default_timer()    print('The code run for %d epochs, with %f epochs/sec' % (epoch, 1. * epoch / (end_time - start_time)))    '''    predict_model = theano.function(        inputs = [index],        outputs = classifier.errors(y),        givens = {            x: test_x[index * batch_size: (index+1) * batch_size],            y: test_y[index * batch_size: (index+1) * batch_size]        }    )    test_ans = [predict_model(i) for i in range(n_test_batch)]    test_error = numpy.mean(test_ans)    print('test error is %f %%' % test_error*100)    '''def predict():    temp = pickle.load(open('best_model.pkl'))    dataset = 'mnist.pkl.gz'    data = load_data(dataset)    test_x, test_y = data[2];    x = T.matrix('x')    y = T.ivector('y')    index = T.iscalar()    classifier = LogisticRegression(x,28*28,10)    classifier.w.set_value (temp.w.get_value())    classifier.b.set_value (temp.b.get_value())     batch_size = 600    n_test_batch = test_x.get_value(borrow = True).shape[0] // batch_size    predict_model = theano.function(        inputs = [index],        outputs = classifier.errors(y),        givens = {            x: test_x[index * batch_size: (index+1) * batch_size],            y: test_y[index * batch_size: (index+1) * batch_size]        }    )    test_ans = [predict_model(i) for i in range(n_test_batch)]    test_error = numpy.mean(test_ans)    print('test error is %f %%' % (test_error*100.) )if __name__ == '__main__':    sgd_optimization_mnist()    predict()