class MLP(object):
    """含单隐层的多层感知机类
    多层感知机是一个前馈人工神经网络模型，该模型有一个或者多个隐含层单元和非线性的激活函数。
    隐层层单元在“HiddenLayer”类中定义
    顶层是一个softmax层，在“LogisticRegression”类中定义
    """
    def __init__(self, rng, input, n_in, n_hidden, n_out):
        """初始化参数
        :type rng: numpy.random.RandomState
        :param rng: 随机数生成器，用于随机生成权重

        :type input: theano.tensor.TensorType
        :param input: 符号，用于表示输入

        :type n_in: int
        :param n_in: 输入单元的个数

        :type n_hidden: int
        :param n_hidden: 隐含层单元的个数

        :type n_out: int
        :param n_out: 输出层单元的个数
        """

        # 输入层到单个隐含层的初始化
        self.hiddenLayer = HiddenLayer(
            rng=rng,#随机数生成器
            input=input,#输入
            n_in=n_in,#输入层的节点个数
            n_out=n_hidden,#输出层的节点个数
            activation=T.tanh#激活函数
        )

        # 隐含层到输出层的初始化
        self.logRegressionLayer = LogisticRegression(
            input=self.hiddenLayer.output,
            n_in=n_hidden,
            n_out=n_out
        )
        # L1正则
        self.L1 = (
            abs(self.hiddenLayer.W).sum()
            + abs(self.logRegressionLayer.W).sum()
        )

        # L2正则
        self.L2_sqr = (
            (self.hiddenLayer.W ** 2).sum()
            + (self.logRegressionLayer.W ** 2).sum()
        )

        # 损失函数的定义
        self.negative_log_likelihood = (
            self.logRegressionLayer.negative_log_likelihood
        )
        # 用于计算validation和testing的错误率
        self.errors = self.logRegressionLayer.errors
        # 声明所有的参数
        self.params = self.hiddenLayer.params + self.logRegressionLayer.params
        #声明输入
        self.input = input

class HiddenLayer(object):
    def __init__(self, rng, input, n_in, n_out, W=None, b=None, activation=T.tanh):
        """在MLP中，典型的隐含层中的节点是全连接的，使用的是sigmoid激活函数，权重矩阵W的大小为(n_in, n_out)，
        偏置向量b的大小为(n_out,)。在这里激活函数使用的是tanh
        :type rng: numpy.random.RandomState
        :param rng: 用于生成权重的随机数生成器

        :type input: theano.tensor.dmatrix
        :param input: 符号，输入

        :type n_in: int
        :param n_in: 输入层的节点个数

        :type n_out: int
        :param n_out: 输出层的节点个数

        :type activation: theano.Op or function
        :param activation: 激活函数的类型
        """
        self.input = input

        if W is None:
            '''对于权重矩阵W中的元素的初始化，若使用的激活函数是tanh，则使用均匀分布在区间[sqrt(-6./(n_in+n_hidden)),sqrt(6./(n_in+n_hidden))]上生成。
            权重矩阵的初始化与选择的激活函数是相关联的。若使用sigmoid激活函数，则生成的数是tanh激活函数的4倍。
            '''
            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的初始化，使用的是全部初始化为0
            '''
            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]

#2、建立模型
print '... building the model'
# 分配全局的符号
index = T.lscalar()  # 用于指示batch
x = T.matrix('x')
y = T.ivector('y')

rng = numpy.random.RandomState(1234)#随机数生成器

# 构造函数
classifier = MLP(
    rng=rng,#随机数生成器
    input=x,#输入
    n_in=28 * 28,#输入的节点个数
    n_hidden=n_hidden,#隐含层节点个数
    n_out=10#输出的节点个数
)

# 在训练的时候，所有的损失是损失函数+L1正则+L2正则
cost = (
    classifier.negative_log_likelihood(y)
        + L1_reg * classifier.L1
        + L2_reg * classifier.L2_sqr
)

#构造验证模型的函数
validate_model = theano.function(
    inputs=[index],#输入为batch的索引
    outputs=classifier.errors(y),#输出为每个batch上的错误率
    givens={#x:样本,y:标签
        x: valid_set_x[index * batch_size:(index + 1) * batch_size],
        y: valid_set_y[index * batch_size:(index + 1) * batch_size]
    }
)

# 对每一个参数求偏导数
gparams = [T.grad(cost, param) for param in classifier.params]

# 更新规则
updates = [
    (param, param - learning_rate * gparam)
    for param, gparam in zip(classifier.params, gparams)
]

# 训练模型的函数
train_model = theano.function(
    inputs=[index],#输入为batch的索引
    outputs=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]
    }
)

#3、训练模型
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
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):

        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 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                    

        if patience <= iter:
            done_looping = True
            break


end_time = timeit.default_timer()
print(('Optimization complete. Best validation score of %f %% '
       'obtained at iteration %i') %
      (best_validation_loss * 100., best_iter + 1))
print >> sys.stderr, ('The code for file ' +
                      os.path.split(__file__)[1] +
                      ' ran for %.2fm' % ((end_time - start_time) / 60.))

'''增加了一段预测的代码
'''
# 4、利用模型进行预测
predict_model = theano.function(
    inputs=[classifier.input],
    outputs=classifier.logRegressionLayer.y_pred)

test_set_x = test_set_x.get_value()

predicted_values = predict_model(test_set_x[:10])#进行预测
print ("Predicted values for the first 10 examples in test set:")
print predicted_values