利用Theano理解深度学习——Convolutional Neural Networks

def load_data(dataset):
'''导入数据
:type dataset: string
:param dataset: MNIST数据集
'''
    #1、处理文件目录
    data_dir, data_file = os.path.split(dataset)#把路径分割成dirname和basename，返回一个元组
    if data_dir == "" and not os.path.isfile(dataset):
        new_path = os.path.join(
                os.path.split(__file__)[0],#__file__表示的是当前的路径
                ".",
                "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'
    #2、打开文件
    f = gzip.open(dataset, 'rb')# 打开一个gzip已经压缩好的gzip格式的文件，并返回一个文件对象：file object.
    train_set, valid_set, test_set = cPickle.load(f)#载入本地的文件
    f.close()
    '''训练集train_set,验证集valid_set和测试集test_set的格式：元组(input, target)
    其中，input是一个矩阵(numpy.ndarray)，每一行代表一个样本；target是一个向量(numpy.ndarray)，大小与input的行数对应
    '''

    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')#将shared_y转换成整型

    #3、将数据处理成需要的形式
    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)

    #4、返回数据集
    rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)]
    return rval

class LeNetConvPoolLayer(object):
    def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
    """
    :type rng: numpy.random.RandomState
    :param rng:用于随机数生成权重 

    :type input: theano.tensor.dtensor4
    :param input:卷积+池化层的输入，是一个4维的张量

    :type filter_shape: tuple or list of length 4
    :param filter_shape: 卷积层过滤器的大小(number of filters, num input feature maps,
                          filter height, filter width)

    :type image_shape: tuple or list of length 4
    :param image_shape: 图像的大小(batch size, num input feature maps,
                         image height, image width)

    :type poolsize: tuple or list of length 2
    :param poolsize: 池化的参数(#rows, #cols)
    """

    assert image_shape[1] == filter_shape[1]
    self.input = input

    #fan_in和fan_out主要用于初始化权重参数
    #卷积层的输入的大小 "num input feature maps * filter height * filter width"
    fan_in = numpy.prod(filter_shape[1:])
    #池化层的输出的大小 "num output feature maps * filter height * filter width" /pooling size
    fan_out = (filter_shape[0] * numpy.prod(filter_shape[2:]) /
               numpy.prod(poolsize))

    #初始化权重
    W_bound = numpy.sqrt(6. / (fan_in + fan_out))
    self.W = theano.shared(
        numpy.asarray(
            rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
            dtype=theano.config.floatX
        ),
        borrow=True
    )

    #初始化偏置
    b_values = numpy.zeros((filter_shape[0],), dtype=theano.config.floatX)
    self.b = theano.shared(value=b_values, borrow=True)

    #定义卷积层
    conv_out = conv.conv2d(
        input=input,#卷积层的输入
        filters=self.W,#卷积层使用的权重
        filter_shape=filter_shape,#每个过滤器的大小
        image_shape=image_shape
    )

    #定义下采样层
    pooled_out = downsample.max_pool_2d(
        input=conv_out,#池化层的输出
        ds=poolsize,#最大池化的大小
        ignore_border=True
    )

    #加上偏置的过程，最终计算非线性映射
    self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))

    #模型中的参数，权重和偏置
    self.params = [self.W, self.b]

    # keep track of model input
    self.input = input

# 三、训练模型
##############################################################################
print '... training'

# early-stopping参数
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 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:

            # 在验证集上计算误差
            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 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_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.))