[kaggle系列 四] 通过mnist来研究神经网络的一些细节（1）

题目

https://www.kaggle.com/c/digit-recognizer

前言

前面玩泰坦尼克号花费了一些时间，想要把分数刷的高一些，但是没有成功，感觉再搞下去意义不大，毕竟只是拿来熟悉kaggle和一些机器学习算法的，目的已经达到了，没必要纠缠下去。所以就开新坑啦~
其实我重点是想要搞神经网络深度学习的，mnist是一个比较简单的数据集，是Yann LeCun大神搞出来的，收集了6，7万个手写数字的图片，对于神经网络来说还是比较容易的，很多教程里都会用mnist来进行入门。
最近也有看CS231n的公开课，前面有讲到一些对于训练比较有用的东西，我的想法是用mnist来把这些东西实践一下，当然，有可能这个数据集的复杂度比较低，用到网络的话也比较浅，可能有些问题触及不到，这个等发现了再说吧，不行就换imageNet之类的试一试，mnist比较小，训练也快，先把能用它实践的先试一试吧~

简析

这个问题是识别手写数字，给出的是一个28*28的图片的灰度值，也就是一个28*28的矩阵，每个位置的值是0-255的整数，数据给的时候把矩阵展开来了，也就是把28*28的矩阵拉成了一行，即784*1。一开始，我打算只用个一层的神经网络写一写，当然了，一层的话还是叫线性分类器更准确一点吧，总之，我们的输入是一个784*1的图片，输出是0~9的类别。
图片的话，用卷积神经网络的准确度会更高，不过我们现在只是为了探讨神经网络中会遇到的一些问题，所以先怎么简单怎么来~
首先是处理数据和训练流程的一些代码，这部分不打算多说，不难写。由于测试集是没有label的，所以我先在训练集里拿了十分之一的数据作为测试集，先用这个测试代码和参数，等一切就绪以后再用全部的数据进行训练。我这里使用了神经网络的训练框架：tensorflow，这个在现在是比较火的啦~ 还是有必要掌握的。

处理数据的代码

总之，先贴一下处理数据之类的代码：

import csv
import os
import numpy as np
import tensorflow as tf
from model_simple import SimpleModel

def readData(fileName):
    result = []
    with open(fileName,'rb') as f:
        rows = csv.reader(f)
        isFirst = True
        count = 0
        for row in rows:
            if isFirst:
                isFirst = False
                continue
            result.append(row)
            count += 1
    return result

def writeData(fileName, data):
    csvFile = open(fileName, 'w')
    writer = csv.writer(csvFile)
    n = len(data)
    for i in range(n):
        writer.writerow(data[i])
    csvFile.close()

def convertData(dataList):
    res = np.array(dataList).astype(float)
    return res

def labelToMat(ylabel):
    n = len(ylabel)
    res = np.zeros((n,10))
    for i in range(n):
        p = int(ylabel[i])
        res[i][p] = 1
    return res

def run():
    dataRoot = '../../kaggledata/mnist/'
    trainData = readData(dataRoot + 'train.csv')
    trainData = convertData(trainData)
    x_input = np.delete(trainData,0,axis=1)
    y_label = labelToMat(trainData.T[0])
    x_input /= 255

    model = SimpleModel()
    n = len(y_label) - int(len(y_label)/10)
    model.build_model()
    print n
    model.train(x_input[:n],y_label[:n])
    #model.init_model('simple.model.ckpt-0')
    predict = model.test(x_input)
    print 'predict len:' + str(len(predict))
    train_acc = 0.
    test_acc = 0.
    for i in range(len(predict)):
        if predict[i] ==  trainData.T[0][i]:
            if i <= n:
                train_acc += 1
            else:
                test_acc += 1
    print train_acc, test_acc
    print 'train_acc is: %.6f, test_acc is %.6f'%(train_acc / n,test_acc/(len(predict) - n) )

def train():
    dataRoot = '../../kaggledata/mnist/'
    trainData = readData(dataRoot + 'train.csv')
    trainData = convertData(trainData)
    x_input = np.delete(trainData,0,axis=1)
    y_label = labelToMat(trainData.T[0])
    x_input /= 255

    model = SimpleModel()
    model.build_model()
    model.train(x_input,y_label)

def test():
    dataRoot = '../../kaggledata/mnist/'
    testData = readData(dataRoot + 'test.csv')
    x_input = convertData(testData)
    x_input /= 255

    model = SimpleModel()
    model.init_model('simple.model.ckpt-0')
    predict = model.test(x_input)
    result = []
    result.append(['ImageId', 'Label'])
    for i in range(len(predict)):
        result.append([i + 1, predict[i] ])
    writeData(dataRoot + 'result.csv', result)

if __name__ == '__main__':
    run()
    # train()
    # test()

模型与代码

在上面代码中，可以看到我写了个模型的类，这个模型主要有三个函数：build_model , train , test。也就是建立模型，训练模型和测试，我们一个一个来说这几个东西。
首先是build一个模型，网络结构非常简单，就是一个线性模型(x*w +b)，然后输出套了个softmax ：

def build_model(self):
        print 'build_model'
        # x对应训练数据或者测试数据，None表示不确定的数量
        # 因为我们训练的时候不是一个数据一个数据去训练的，而是选一组数据作为一个batch
        # 每次用一个batch去训练，这个batch其实也是个超参数，需要调的
        self.x = tf.placeholder(tf.float32,[None, 784])
        # W 和 b 就是我们需要训练的参数
        self.W = tf.Variable(tf.random_normal([784,10], stddev=1),name='weights')
        self.b = tf.Variable(tf.zeros([10]),name='biases')
        # 输出后面用个softmax以用来分类
        self.y = tf.nn.softmax( tf.matmul(self.x,self.W) + self.b)
        # 实际的结果(label)
        self.label = tf.placeholder(tf.float32,[None,10])
        # 使用交叉熵作为损失函数
        self.cross_entropy = -tf.reduce_sum(self.label*tf.log(self.y))
        # 使用梯度下降进行训练，learning_rate（学习率）是一个超参数，我用的0.01
        opt = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate)
        self.train_step = opt.minimize(self.cross_entropy)

        # 启动模型和保存模型的一些代码
        config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)
        self.sess = tf.Session(config=config)
        init = tf.global_variables_initializer()
        self.sess.run(init)
        self.saver = tf.train.Saver(tf.global_variables())

build模型的话，需要注意的问题有两个，一个是参数初始化的问题，如果我把W初始化为0了，会怎么样呢？就像这样：

    self.W = tf.Variable(tf.zeros([784,10]),name='weights')

答案是你的模型可能没办法训练下去，你会发现在某个时刻，你的loss有概率会变为nan：

为什么会这样呢？我们可以看一下交叉熵函数:

$$C = -\sum_i{y_i \ln {a_i}}$$

有个ln，我们看一下y = ln x的图像，就会发现，当我们的y非常小，甚至为0的时候，就会导致loss变为nan。

为了减少这种情况的发生，我们可以使用高斯分布来对参数进行初始化，简单来说，就是让参数的初始值稍微大一些，防止计算结果为0导致梯度计算出问题。我在这里用了个正态分布来初始化参数，但是还是有几率出现loss变成nan的情况。只有一层的网络都有这个问题，对于层数更多的网络更需要注意，如果参数初始化出了问题，训练就有可能无法进行下去，这个问题后面在继续说一说，层数变多会出现另外的问题。

另一个问题就是学习率，这是个需要调整的超参数，学习率太大会导致后面学不下去，太小会导致学习速度非常慢而且很难达到最优点。

接下来是训练和测试模型的代码。首先，我们要明确训练的时候，我们数据不是一次训练把所有的数据都用上，而是挑选一部分作为一个batch进行训练的，这个batch的大小也是一个超参数，需要人手工调整的。然后训练会经历几轮，我们称为epoch，为了保证训练比较充分，一般会多训个几轮。怎样选取batch也是个问题，最好选batch是让数据的分布是随机的，这样有助于减轻神经网络学习的时候发生过拟合。不过在个训练中训练轮数也不多，而且数据给的时候已经是随机的了，所以影响不大，不过我还是写了个随机选取batch的函数。

下面就直接贴完整代码吧，训练和测试的代码还是比较简单的：

import os
import numpy as np
import tensorflow as tf
import random

class SimpleModel(object):
    def __init__(self):
        self.learning_rate = 0.01
        self.batch_size = 200

    def build_model(self):
        print 'build_model'
        self.x = tf.placeholder(tf.float32,[None, 784])
        self.W = tf.Variable(tf.random_normal([784,10], stddev=1),name='weights')
        self.b = tf.Variable(tf.zeros([10]),name='biases')
        self.y = tf.nn.softmax( tf.matmul(self.x,self.W) + self.b)
        self.label = tf.placeholder(tf.float32,[None,10])
        self.cross_entropy = -tf.reduce_sum(self.label*tf.log(self.y))
        opt = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate)
        self.train_step = opt.minimize(self.cross_entropy)

        config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)
        self.sess = tf.Session(config=config)
        init = tf.global_variables_initializer()
        self.sess.run(init)
        self.saver = tf.train.Saver(tf.global_variables())

    def randomBatch(self,size, epoch):
        self.data_tags = []
        for i in range(epoch):
            for j in range(size):
                self.data_tags.append(j)
        random.shuffle(self.data_tags)
        self.data_pos = 0

    def getNextBatch(self, x_inputs, y_labels):
        batch_x = []
        batch_y = []
        m = len(self.data_tags)
        for i in range(self.batch_size):
            p = self.data_tags[self.data_pos]
            self.data_pos = (self.data_pos + 1)%m
            batch_x.append(x_inputs[p])
            batch_y.append(y_labels[p])
        return np.array(batch_x),np.array(batch_y)

    def train(self,x_inputs, y_labels):
        pos = 0
        count = 0
        epoch = 5
        total = int(len(x_inputs)/self.batch_size)
        self.randomBatch(len(x_inputs),epoch)
        for i in range(epoch*total):
            x_batch,y_batch = self.getNextBatch(x_inputs,y_labels)
            loss,_ = self.sess.run([self.cross_entropy,self.train_step],feed_dict={self.x:x_batch,self.label:y_batch})

            count += 1
            if count % 50 == 0:
                print 'step %d: ,loss:%.6f' % (count, loss)

        self.saver.save(self.sess, './train_models/simple.model.ckpt',global_step=0)

        print 'train over'

    def init_model(self,modelName):
        self.build_model()
        self.saver.restore(self.sess, os.path.join('./train_models/',modelName) )

    def test(self, x):
        predict = self.sess.run(self.y, feed_dict={self.x:x})
        res = np.argmax(predict, axis=1)
        return res

结论

这个模型最终的准确率有0.89871，一点都不高，在kaggle上也是垫底，不过我们至少有了一个baseline，接下来我会把网络多加几层看看效果，然后通过这个测试一些神经网络需要注意的问题~