Kaggle - Digit Recognizer 手写数字识别 -> KNN 和 fully connected neural network 以及 CNN实现

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

此题目已经把每个图片向量化了。下载到的data里包含三个文件：

数据文件train.csv和test.csv包含从0到9的手绘数字的灰度图像。

每个图像的高度为28个像素，宽度为28个像素，总共为784个像素。每个像素具有与其相关联的单个像素值，指示该像素的亮度或暗度，较高的数字意味着较暗。该像素值是0到255之间的整数，包括0和255。

训练数据集（train.csv）有785列。第一列称为“标签”，是用户绘制的数字。其余列包含关联图像的像素值。

训练集中的每个像素列都具有像pixelx这样的名称，其中x是0到783之间的整数，包括0和783。为了在图像上定位该像素，假设我们已经将x分解为x = i * 28 + j，其中i和j是0到27之间的整数，包括0和27。然后，pixelx位于28 x 28矩阵的第i行和第j列上（索引为零）。

例如，pixel31表示从左边开始的第四列中的像素，以及从顶部开始的第二行，如下面的ascii图中所示。

在视觉上，如果我们省略“像素”前缀，像素组成图像如下：

000 001 002 003 ... 026 027
028 029 030 031 ... 054 055
056 057 058 059 ... 082 083
 | | | | ...... | |
728 729 730 731 ... 754 755
756 757 758 759 ... 782 783 

测试数据集（test.csv）与训练集相同，只是它不包含“标签”列。

K近邻

具体代码如下：

import numpy as np  # linear algebra
import csv

import operator
import os
import time  # 会用到时间函数
# print(os.listdir("./data"))  # 列出此文件夹下的所有文件目录

"""

train_mat 是训练数据组成的矩阵，即train.csv去掉表头 和 每一行的第一个数(label)之后的剩余部分

"""
def digitRecognizer():
    train_labels = []  # 存储 训练数据的标签
    test_labels = []  # 存储 测试数据的标签
    train_list = []  # 存储 去除表头的所有列表
    test_list = []   # 存储 去除表头的所有测试数据列表
    len_train = 0  # 存储 训练集的个数
    with open('./data/train.csv') as f:
        content = csv.reader(f)
        dot = 0
        for one in content:
            if dot > 0:
                # trans_int = [ int(i) for i in one ] 或者用下面的方法
                trans_int = list(map(int, one))  # 把列表中的str全部转化成int类型
                train_list.append(trans_int)
            dot += 1
        len_train = len(train_list)
    # 因为list不支持list**2操作（幂乘），所以需要转化成numpy矩阵的形式。
    train_mat = np.zeros((len_train, 784))  # numpy.matrix类型，用0填充一个 len_train*784的矩阵
    dot = 0
    for one in train_list:
        train_labels.append(one[0])
        train_mat[dot, :] = one[1:]
        dot += 1
    # print(train_mat.shape) # (42000, 784)

    with open('./data/test.csv') as f:
        content = csv.reader(f)
        dot = 0
        for one in content:
            if dot > 0:
                # trans_int = [ int(i) for i in one ] 或者用下面的方法
                trans_int = list(map(int, one))  # 把列表中的str全部转化成int类型
                test_list.append(trans_int)
            dot += 1
    # print(len(test_list))  # 返回 28000
    dot = 1
    for ele in test_list:
        result = classify(ele, train_mat, train_labels, 5)  # k=5
        test_labels.append(result)

        # print(result)
        dot += 1
        if dot % 1000 == 0:  # 每一千次输出一次时间
            print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))

    # 写ans文件
    with open('./data/ans.csv', 'w', encoding='UTF-8', newline='') as f:
        head = ['ImageId', 'Label']
        ww = csv.writer(f)
        ww.writerow(head)
        for i in range(len(test_labels)):
            mid = [str(i + 1), str(test_labels[i])]
            ww.writerow(mid)
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))


def classify(inX, data_set, labels, k):  # 分类函数，k近邻判断结果所属类别
    data_set_size = data_set.shape[0]  # 返回 矩阵行数
    diff_mat = np.tile(inX, (data_set_size, 1)) - data_set  # 计算此测试向量 与 矩阵中每一个行向量中元素的差值
    sq_diff_mat = diff_mat ** 2  # 各个差值求平方
    sq_distance = sq_diff_mat.sum(axis=1)  # 按行向量求和
    distance = sq_distance ** 0.5  # 再开方，此时得到的是此测试向量到各个训练数据的 欧氏距离
    sorted_dis = distance.argsort()  # 将 距离 升序排序, 返回的是对应的index索引号
    class_count = {}
    for i in range(k):
        vote = labels[sorted_dis[i]]
        class_count[vote] = class_count.get(vote, 0) + 1
    sorted_class_count = sorted(class_count.items(), key=operator.itemgetter(1), reverse=True)
    return sorted_class_count[0][0]
    """
    # 上面sorted函数的第一个参数是可迭代的对象
    # operator.itemgetter(1)是获取可迭代对象中 第一个域的值（从0开始），即对字典的value值排序
    # reverse=True 表示排序完成之后(默认从小到大)，再逆序。即由大到小排序
    # 排序完成之后，最大的值在最前面。并且返回的是list
    # 例如：待排序的dist为{'b':111, 'a':666}, 返回的结果是[('a', 666), ('b', 111)]，tuple也是可以按下标索引的
    
    """


if __name__ == '__main__':
    digitRecognizer()

可以看到训练集有42000条数据，每条数据有784（28像素*28像素）个数字。测试集有28000条数据，每条也有784个数字。

在进行距离的计算时，需要将测试集里的每一条数据 分别计算到训练集4.2万个‘图’的每一个距离。即算法要为每个测试向量做42000次的距离计算，并且每个距离计算包含784个浮点运算，然后还需要开方，总计要计算28000次(28000个测试数据)。

总计算次数数量级：几乎是千亿级别了。（784*4.2万*2.8万 = 9219.84亿）所以可以看出会非常耗时。

我运行此代码的时候大致输出了一下时间，内存12G, i5CPU 无SSD大概运行了仨小时。-_-#

得到了ans.csv文件

内容形如：

然后满怀期待的进行了提交...：）

额... 可以看到准确率为96.900%

用的k近邻算法，k的值选取为5.

并且我观察了一下，发现向量中大部分为0值，就没进行归一化( normalization )。

不过在两千多组提交中排名一千六百多，这成绩还是很不理想的。

 

Neural Network 

        - 3 level, 500 hidden nodes, 7 epoch, learning rate is 0.1

        - Accuracy  97.371%

import numpy
import csv
import matplotlib.pyplot as plt
import time


# 在训练神经网络的过程中有两个阶段，第一个阶段：计算输出，如同query()所做的事情
# 第二个阶段就是反向转播误差，告知如何优化链接权重
# neural network class definition
class neuralNetwork:
    # initialise the neural network
    def __init__(self, input_n, hidden_n, output_n, learning_rate):
        self.inodes = input_n
        self.hnodes = hidden_n
        self.onodes = output_n

        self.lrate = learning_rate

        # 权重矩阵
        #         self.Wi_h = numpy.random.rand(self.hnodes, self.inodes) - 0.5
        #         self.Wh_o = numpy.random.rand(slef.onodes, self.hnodes) - 0.5

        # 符合正态分布的权重
        # numpy.random.normal(平均值, 标准方差--即节点数目的-0.5次方, numpy数组大小)
        self.Wi_h = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        self.Wh_o = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))

    def Sigmod(self, x):
        return 1.0 / (1 + numpy.exp(-x * 1.0))

    # train the neural network
    def train(self, inputs_list, targets_list):
        inputs = numpy.array(inputs_list, ndmin=2).T  # shape 为n*1的列向量
        targets = numpy.array(targets_list, ndmin=2).T

        hidden_inputs = numpy.dot(self.Wi_h, inputs)  # 矩阵点乘
        hidden_outputs = self.Sigmod(hidden_inputs)  # S函数

        final_inputs = numpy.dot(self.Wh_o, hidden_outputs)
        final_outputs = self.Sigmod(final_inputs)  # S函数
        # 输出层误差
        output_errors = targets - final_outputs
        # 隐含层误差计算
        hidden_errors = numpy.dot(self.Wh_o.T, output_errors)  # 去除归一化权重的误差
        # 更新（训练）权重矩阵
        self.Wh_o += self.lrate * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))
        self.Wi_h += self.lrate * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))

    # query the neural network
    def query(self, inputs_list):
        inputs = numpy.array(inputs_list, ndmin=2).T  # 维度为2 然后转秩

        hidden_inputs = numpy.dot(self.Wi_h, inputs)  # 矩阵点乘
        hidden_outputs = self.Sigmod(hidden_inputs)  # S函数

        final_inputs = numpy.dot(self.Wh_o, hidden_outputs)
        final_outputs = self.Sigmod(final_inputs)  # S函数

        return final_outputs

    def file_read(self):
        road = 'F:\\KaggleInAction\\Digit_Recognizer\\data\\train.csv'
        data = []
        index = []
        with open(road, encoding='utf-8') as f:
            f.readline()  # 略掉首行
            contents = csv.reader(f)
            for line in contents:
                mid = (numpy.asfarray(line[1:])/255.0*0.99) + 0.01  # 将文本类型数据转换成数值类型 并缩放到0.01-1 之间
                data.append(mid)
                index.append(int(line[0]))
                # print(line)
                # # numpy.asfarray() 将str类型的数据 转成 数值类型的数据
                # image_array = numpy.asfarray(line[1:]).reshape((28, 28))
                # # cmap='Greys' 是灰度调色板
                # plt.imshow(image_array, cmap='Greys', interpolation='None')
                # plt.show()
        return data, index


if __name__ == '__main__':
    print('Begin: ', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 开始时刻
    input_nodes = 784  # 输入层节点784个 即输入的数据是一个 784*1 的向量
    hidden_nodes = 500  # 设置隐含层节点 500个
    output_nodes = 10  # 输出层节点 10个

    learning_rate = 0.1

    n = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)

    for epoch in range(7):  # 权重只初始化一次，将数据集多次训练(此处是7次), 但注意：训练次数过多会导致过拟合
        data, key = n.file_read()
        target_list = []
        for num in key:
            matrix = numpy.zeros(output_nodes) + 0.01  # 创建每个训练数据的目标输出
            matrix[num] = 0.99
            target_list.append(matrix)
        for i in range(len(data)):
            n.train(data[i], target_list[i])  # 训练权重矩阵(训练神经网络)
        print('epoch', epoch)  # 输出epoch次数

    # way = './mnist_test.csv'
    way = 'F:\\KaggleInAction\\Digit_Recognizer\\data\\test.csv'
    test = []
    # ans = []
    res = []
    cnt = 0
    with open(way, encoding='utf-8') as f:
        f.readline()  # 略掉首行
        for line in f:
            ss = line.strip('\n').split(',')
            # ans.append(int(ss[0]))
            test = numpy.asfarray(ss)
            mid = n.query((test/255.0*0.99) + 0.01)
            label = numpy.argmax(mid)
            res.append(label)
    # for i in range(len(ans)):
    #     if ans[i] == res[i]:
    #         cnt += 1
    with open('F:\\KaggleInAction\\Digit_Recognizer\\data\\neural_network_ans.csv', 'w', encoding='utf-8') as f:
        f.write('ImageId,Label' + '\n')
        for i in range(len(res)):
            f.write(str(i+1) + ',' + str(res[i]) + '\n')
    print('Done... ', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 运行结束时刻
    # print('performance = ', cnt*1.0/len(ans))

运行时间大概半个小时

排名还是那么靠后... /手动捂脸

 

CNN

epoch=5 batch_size=64 optimizer='rmsprop' activation='relu' last_activation='softmax'

from keras import models
from keras import layers
import numpy as np
import pandas as pd
import time

print('Begin...', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 开始时间

# 换成你的文件路径
img_train = pd.read_csv('F:/KaggleInAction/Digit_Recognizer/data/train.csv')
img_test = pd.read_csv('F:/KaggleInAction/Digit_Recognizer/data/test.csv')

# 将原始数据转换为图片格式，利用CNN，图片格式(m, n_H, n_W, n_C)
img_train = np.array(img_train)
img_test = np.array(img_test)

train_images = np.zeros((img_train.shape[0], 28, 28, 1))
train_labels = np.zeros(img_train.shape[0])
test_images = np.zeros((img_test.shape[0], 28, 28, 1))
test_labels = np.zeros(img_test.shape[0])

for i in range(img_train.shape[0]):
    train_images[i] = img_train[i][1:].reshape(28, 28, 1)
    train_labels[i] = img_train[i][0].astype(int)
for i in range(img_test.shape[0]):
    test_images[i] = img_test[i].reshape(28, 28, 1)

# Normalization
train_images = train_images.astype('float32') / 255
test_images = test_images.astype('float32') / 255


# 将整数序列编码为二进制矩阵
def vectorize_sequences(sequences, dimension=10):
    results = np.zeros((len(sequences), dimension), dtype='float32')
    for i, sequence in enumerate(sequences):
        results[i, int(sequence)] = 1.
    return results


train_labels = vectorize_sequences(train_labels)  # (42000,) -> (42000, 10)
test_labels = vectorize_sequences(test_labels)  # (28000,) -> (28000, 10)

print(train_images.shape)  # (42000, 28, 28, 1)
print(train_labels.shape)  # (42000, 10)
print(test_images.shape)  # (28000, 28, 28, 1)
print(test_labels.shape)  # (28000, 10) 目前全0


# 模型
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

# 3D 转成 1D
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
history = model.fit(train_images, train_labels, epochs=5, batch_size=64)
# print(history.history.keys())
# test_loss, test_acc = model.evaluate(test_images, test_labels)
# print(test_loss)
# print(test_acc)
pred = model.predict(test_images, batch_size=256)  # 预测结果
print(pred.shape)
pred_X = np.argmax(pred, axis=1)
# print(pred_X)  # [2 0 9 ... 3 9 2] 就是那2800个测试数据的标签

# 写文件 # 换成你的文件路径
result = pd.DataFrame({'ImageId': np.arange(1, 28001), 'Label': pred_X})
result.to_csv("F:/KaggleInAction/Digit_Recognizer/cnn_ans.csv", index=False)

print('End...', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 结束时间

大约运行了2分钟

然后迫不及待的summit 

Accuracy 为 98.828% 终于杀进前 50%了.... -_-#

后续会给出别的解法。

有问题请留言，欢迎转发，转发需标明出处。

 

稍后补充更新...