卷积神经网络

class ConvPoolLayer(object):
    """ 卷积层 """
    
    def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
        """
        rng
            类型：numpy.random.RandomState
            描述：用于初始化权值的随机数产生器
        input
            类型：theano.tensor.dtensor4
            描述：图像数据      
        filter_shape
            类型：长度为4的元组或序列
            描述：（过滤器数量，输入的特征图数量，过滤器高度，过滤器宽度）
        image_shape
            类型：长度为4的元组或序列
            描述：（batch size，输入的特征图数量，图像高度，图像宽度）      
        poolsize
            类型：长度为2的元组或序列
            描述：下采样系数（#rows, #cols）
        """

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

        # 每个神经元的输入 = 输入的特征图数量 * 过滤器高度 * 过滤器宽度
        fan_in = numpy.prod(filter_shape[1:])

        # 每个神经元的输出 = （输出的特征图数量 * 过滤器高度 * 过滤器宽度）/ 池大小
        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]

class HiddenLayer(object):
    """ 隐层 """
    
    def __init__(self, rng, input, n_in, n_out, W=None, b=None,
                 activation=T.tanh):
        """
        rng
            类型：numpy.random.RandomState
            描述：用于初始化权值的随机数产生器
        input
            类型：theano.tensor.dmatrix
            描述：输入数据
        n_in
            类型：int
            描述：输入数据的大小
        n_out
            类型：int
            描述：神经元数量
        activation
            类型：theano.Op或函数
            描述：非线性，用于隐层的激活
        """
        
        self.input = input

        # 初始化权值
        if W is None:
            W_values = numpy.asarray(
                rng.uniform(
                    low=-numpy.sqrt(6. / (n_in + n_out)),
                    high=numpy.sqrt(6. / (n_in + n_out)),
                    size=(n_in, n_out)
                ),
                dtype=theano.config.floatX
            )
            if activation == theano.tensor.nnet.sigmoid:
                W_values *= 4
            W = theano.shared(value=W_values, name=‘W‘, borrow=True)
        
        # 初始化偏差
        if b is None:
            b_values = numpy.zeros((n_out,), dtype=theano.config.floatX)
            b = theano.shared(value=b_values, name=‘b‘, borrow=True)

        self.W = W
        self.b = b

        # 激活
        lin_output = T.dot(input, self.W) + self.b
        self.output = (
            lin_output if activation is None
            else activation(lin_output)
        )
        
        self.params = [self.W, self.b]

class LogisticRegression(object):
    """ 逻辑回归 """
    
    def __init__(self, input, n_in, n_out):
        """
        input
            类型：theano.tensor.TensorType
            描述：输入数据               
        n_in
            类型：int
            描述：输入单元的个数
        n_out
            类型：int
            描述：输出单元的个数
        """
        
        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.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
        
        # 分类结果
        self.y_pred = T.argmax(self.p_y_given_x, axis=1)
       
        self.params = [self.W, self.b]

    def negative_log_likelihood(self, y):
        """ 返回该模型的对于某一指定变量的最小负的对数似然函数值 """
        return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])

    def errors(self, y):
        # 检查与预测值是否有相同的维数
        if y.ndim != self.y_pred.ndim:
            raise TypeError(
                ‘y should have the same shape as self.y_pred‘,
                (‘y‘, y.type, ‘y_pred‘, self.y_pred.type)
            )
        # 检查数据类型是否正确
        if y.dtype.startswith(‘int‘):
            return T.mean(T.neq(self.y_pred, y))
        else:
            raise NotImplementedError()