如何写一个游戏AI（三）0-9手写数字图片识别AI训练

心已赠人 2023-03-04 13:23 29阅读 0赞

接上回书，那么如何写一个入门的简单AI训练（0-9）数字图片试别AI。本文的程序，配合我训练的模型试别准确率只有98.8%，不过也是算是给我开辟了新的知识面。

##     1.为什么使用卷积神经网络 ##

原因有二：1.直观上，使用卷积比全连接网络少很多参数（百度上说的）；2.我经理直接叫我用这个。哈哈哈哈 = =，我只是大概知道，可以用来处理图像。如果有同僚看到这篇文章，有别的见解欢迎指出。

##     **2.在写这个训练AI的代码之前，需要准备什么** ##

**       ** 使用卷积训练AI，也就是教会AI试别各种数字的是需要大量的数据进行训练了。**因为是入门，所以我的训练图片是32\*32的黑白图像，也就是用画图工具画出来的。**0-9每个数字画了十张。然后写了个python脚本，用每个数字的10张样本，经过简单平移或者旋转生成1000张图。0-9总共是10000张图作为所有的输入数据。**设计好输入和输入**，安装好相应的库，例如**tensorflow，numpy**。

##     3.代码主要分为4个部分：读取图片，读取训练集和校验集，训练，使用模型 ##

下面开始进入代码部分，代码部分有足够的注释：

**a.读取图片：**

def read_sample(file_path):
        ret = numpy.zeros((32, 32))                 #使用numpy构建32*32的数组
        im = Image.open(file_path)
        rgb_im = im.convert('RGB')                  #将打开的image指定真彩色模式 
        for i in range(32):
            for j in range(32):
                r, g, b = rgb_im.getpixel((i, j))   #读取每个点的r,g,b
                average = (r + b + g)/3             
                if average >= 127:                  #因为是黑白图像，非黑即白rgb三原色综合是255，所以可以使用127来区分
                    ret[i, j] =  0
                else:
                    ret[i, j] = 1
    
        return ret
    
    # 可以使用以下代码输入一下看看图形转化为数字输入的结果
    # ret = read_sample("C:/Users/bfs/Desktop/learning_ai/0/0_1.png")  
    # for j in range(32):
    #     for i in range(32):
    #         print(int(ret[i, j]), end=' ')
    #     print('')      
    #

这里随便使用一张图0的图打印结果如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhbmZ1c2hlbjAwNw_size_16_color_FFFFFF_t_70][]

可以清晰的看到，转换成数字输入的结果，的确是一个0。

**         b.读取训练集和校验集**

这里补充一下，在所有的数据里面，需要把数据分为训练和校验。校验用来验证训练的结果。校验满意后，再生成模型。之后就是直接使用模型了。

def read_trainset_and_validateset():
        trainset_samples = []               #定义训练集
        validateset_samples = []            #定义校验集
    
        for i in range(10):
            for root, dirs, files in os.walk("out/"+str(i), topdown=False):
                for name in files:
                    pic_path = os.path.join(root, name)
                    rand_num = random.random()
                    if rand_num > 0.9:                                            #90%为训练集，剩下10%为校验集
                        trainset_samples.append( (read_sample(pic_path), i) )     #插入训练集，内容为 （图像内容，数字）
                    else:
                        validateset_samples.append( (read_sample(pic_path), i) )  #插入校验集，内容为 （图像内容，数字）
    
        return (trainset_samples, validateset_samples)

**c.训练**

def train():
        print("loading....")
        trainset_samples, valideteset_samples = read_trainset_and_validateset()    #获取训练集和校验集
        x = numpy.zeros((len(trainset_samples), 32, 32, 1))                        #构建训练集, 10个32*32的1通道神经元输入
        y = numpy.zeros((len(trainset_samples), 10))                               #构建训练集, 二维0-9的神经元输出
        validate_x = numpy.zeros((len(valideteset_samples), 32, 32, 1))            #构建校验集, 10个32*32的1通道神经元输入
        validate_y = numpy.zeros((len(valideteset_samples), 10))                   #构建校验集, 二维0-9的神经元输出
        print("conver......")
    
        for i in range(len(trainset_samples)):
            sample, sample_out = trainset_samples[i]            #sample对应读取的图像结果, sample_out对应结果为哪个数字
            for xi in range(32):    
                for yi in range(32):
                    x[i, xi, yi, 0] = sample[xi, yi]            #训练集输入, i对应目前是哪个神经元的输入, sample为读取图像的结果
    
            y[i, sample_out] = 1                                #训练集输出, 意思为这个神经元的输出结果为1, 即当以上神经元输入时,对应的这个神经元的sample_out的预测结果为1(100%)
    
        for i in range(len(valideteset_samples)):
            sample, sample_out = valideteset_samples[i]         #sample对应读取的图像结果, sample_out对应结果为哪个数字
            for xi in range(32):
                for yi in range(32):
                    validate_x[i, xi, yi, 0] = sample[xi, yi]   #校验集输入, i对应目前是哪个神经元的输入, sample为读取图像的结果
    
            validate_y[i, sample_out] = 1                       #校验集输出, 意思为这个神经元的输出结果为1, 即当以上神经元输入时,对应的这个神经元的sample_out的预测结果为1(100%)
    
        input = keras.Input(shape=(32,32,1))                                                    #输入层，32*32个神经元输入，一个输入通道，因为只是一个二维的黑白图像，一个输入通道即可。复杂的情况则需要多个输入通道，可以自己看看别的例子
        layer = keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation='relu')(input)    #卷积层，5*5个神经元感受视野，32个卷积核，激励函数relu做非线性映射
        layer = keras.layers.Conv2D(filters=8, kernel_size=(5,5), activation='relu')(layer)     #卷积层，5*5个神经元感受视野，8个卷积核，激励函数relu做非线性映射
        layer = keras.layers.MaxPool2D(pool_size=(2, 2))(layer)                                 #池化层，maxpool取“池化视野”矩阵中的最大值，当输入经过卷积层时，得到的feature map （特征图）还是比较大，可以通过池化层来对每一个 feature map 进行降维操作
        layer = keras.layers.Dropout(rate=0.4)(layer)                                           #该层的作用相当于对参数进行正则化来防止模型过拟合
        layer = keras.layers.Flatten()(layer)                                                   #将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。
        layer = keras.layers.Dense(128, activation='relu')(layer)                               #全连接层，有128个神经元，激活函数采用‘relu’
        layer = keras.layers.Dense(10, activation='softmax')(layer)                             #输出层，有10个神经元，每个神经元对应一个类别，输出值表示样本属于该类别的概率大小。
    
        model = keras.Model(input, layer)                                                       #创建模型
        model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])  #指定一些参数
        print("training.....")
        model.fit(x=x, y=y, batch_size=200, epochs=40, validation_data=(validate_x, validate_y)) #训练模型
    
        # model.save('C:/Users/bfs/Desktop/learning_ai/pictrue_model.h5')  #训练满意的话则保存
    
        return model

训练结果为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhbmZ1c2hlbjAwNw_size_16_color_FFFFFF_t_70 1][]       可以看到校验集的校验结果精确度达到98.8%左右

**d.使用模型**

def verify_modle():
        m_model = keras.models.load_model('C:/Users/bfs/Desktop/learning_ai/pictrue_model'+'.h5')
        verify_sample = read_sample('C:/Users/bfs/Desktop/learning_ai/3.png')  #我这里随便使用一张图片来进行实际预测
        test_x = numpy.zeros((1, 32, 32, 1))
        for xi in range(32):
                for yi in range(32):
                    test_x[0, xi, yi, 0] = verify_sample[xi, yi]
        predict_result = m_model.predict(x=test_x)               #导入实际使用时的图片数据
    
        ret = 0
        max_prob = max(predict_result[0])                        #返回最大的概率。训练结果是一个二维数组，相当于一列0-9的概率。最大的概率则为预测结果
        for x in range(10):
            if max_prob == predict_result[0, x]:
                ret = x
        
        print('解析图片结果结果为', ret)

###       以下为完整代码： ###

#coding:utf-8
    from PIL import Image, ImageChops
    import os
    import numpy
    import random
    import numpy as np
    import tensorflow as tf
    from tensorflow import keras
    
    def read_sample(file_path):
        ret = numpy.zeros((32, 32))                 #使用numpy构建32*32的数组
        im = Image.open(file_path)
        rgb_im = im.convert('RGB')                  #将打开的image指定真彩色模式 
        for i in range(32):
            for j in range(32):
                r, g, b = rgb_im.getpixel((i, j))   #读取每个点的r,g,b
                average = (r + b + g)/3             
                if average >= 127:                  #因为是黑白图像，非黑即白rgb三原色综合是255，所以可以使用127来区分
                    ret[i, j] =  0
                else:
                    ret[i, j] = 1
    
        return ret
    
    def read_trainset_and_validateset():
        trainset_samples = []               #定义训练集
        validateset_samples = []            #定义校验集
    
        for i in range(10):
            for root, dirs, files in os.walk("out/"+str(i), topdown=False):
                for name in files:
                    pic_path = os.path.join(root, name)
                    rand_num = random.random()
                    if rand_num > 0.9:                                            #90%为训练集，剩下10%为校验集
                        trainset_samples.append( (read_sample(pic_path), i) )     #插入训练集，内容为 （图像内容，数字）
                    else:
                        validateset_samples.append( (read_sample(pic_path), i) )  #插入校验集，内容为 （图像内容，数字）
    
        return (trainset_samples, validateset_samples)
    
    
    # ret = read_sample("C:/Users/bfs/Desktop/learning_ai/0/0_1.png")  
    # for j in range(32):
    #     for i in range(32):
    #         print(int(ret[i, j]), end=' ')
    #     print('')      
    # 
     
    def train():
        print("loading....")
        trainset_samples, valideteset_samples = read_trainset_and_validateset()    #获取训练集和校验集
        x = numpy.zeros((len(trainset_samples), 32, 32, 1))                        #构建训练集, 10个32*32的1通道神经元输入
        y = numpy.zeros((len(trainset_samples), 10))                               #构建训练集, 二维0-9的神经元输出
        validate_x = numpy.zeros((len(valideteset_samples), 32, 32, 1))            #构建校验集, 10个32*32的1通道神经元输入
        validate_y = numpy.zeros((len(valideteset_samples), 10))                   #构建校验集, 二维0-9的神经元输出
        print("conver......")
    
        for i in range(len(trainset_samples)):
            sample, sample_out = trainset_samples[i]            #sample对应读取的图像结果, sample_out对应结果为哪个数字
            for xi in range(32):    
                for yi in range(32):
                    x[i, xi, yi, 0] = sample[xi, yi]            #训练集输入, i对应目前是哪个神经元的输入, sample为读取图像的结果
    
            y[i, sample_out] = 1                                #训练集输出, 意思为这个神经元的输出结果为1, 即当以上神经元输入时,对应的这个神经元的sample_out的预测结果为1(100%)
    
        for i in range(len(valideteset_samples)):
            sample, sample_out = valideteset_samples[i]         #sample对应读取的图像结果, sample_out对应结果为哪个数字
            for xi in range(32):
                for yi in range(32):
                    validate_x[i, xi, yi, 0] = sample[xi, yi]   #校验集输入, i对应目前是哪个神经元的输入, sample为读取图像的结果
    
            validate_y[i, sample_out] = 1                       #校验集输出, 意思为这个神经元的输出结果为1, 即当以上神经元输入时,对应的这个神经元的sample_out的预测结果为1(100%)
    
        input = keras.Input(shape=(32,32,1))                                                    #输入层，32*32个神经元输入，一个输入通道，因为只是一个二维的黑白图像，一个输入通道即可。复杂的情况则需要多个输入通道，可以自己看看别的例子
        layer = keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation='relu')(input)    #卷积层，5*5个神经元感受视野，32个卷积核，激励函数relu做非线性映射
        layer = keras.layers.Conv2D(filters=8, kernel_size=(5,5), activation='relu')(layer)     #卷积层，5*5个神经元感受视野，8个卷积核，激励函数relu做非线性映射
        layer = keras.layers.MaxPool2D(pool_size=(2, 2))(layer)                                 #池化层，maxpool取“池化视野”矩阵中的最大值，当输入经过卷积层时，得到的feature map （特征图）还是比较大，可以通过池化层来对每一个 feature map 进行降维操作
        layer = keras.layers.Dropout(rate=0.4)(layer)                                           #该层的作用相当于对参数进行正则化来防止模型过拟合
        layer = keras.layers.Flatten()(layer)                                                   #将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。
        layer = keras.layers.Dense(128, activation='relu')(layer)                               #全连接层，有128个神经元，激活函数采用‘relu’
        layer = keras.layers.Dense(10, activation='softmax')(layer)                             #输出层，有10个神经元，每个神经元对应一个类别，输出值表示样本属于该类别的概率大小。
    
        model = keras.Model(input, layer)                                                       #创建模型
        model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])  #指定一些参数
        print("training.....")
        model.fit(x=x, y=y, batch_size=200, epochs=40, validation_data=(validate_x, validate_y)) #训练模型
    
        model.save('C:/Users/bfs/Desktop/learning_ai/pictrue_model.h5')
    
        return model
    
    def verify_modle():
        m_model = keras.models.load_model('C:/Users/bfs/Desktop/learning_ai/pictrue_model'+'.h5')
        verify_sample = read_sample('C:/Users/bfs/Desktop/learning_ai/3.png')  #我这里随便使用一张图片来进行实际预测
        test_x = numpy.zeros((1, 32, 32, 1))
        for xi in range(32):
                for yi in range(32):
                    test_x[0, xi, yi, 0] = verify_sample[xi, yi]
        predict_result = m_model.predict(x=test_x)               #导入实际使用时的图片数据
    
        ret = 0
        max_prob = max(predict_result[0])                        #返回最大的概率。训练结果是一个二维数组，相当于一列0-9的概率。最大的概率则为预测结果
        for x in range(10):
            if max_prob == predict_result[0, x]:
                ret = x
        
        print('解析图片结果结果为', ret)
    
    if __name__ == "__main__":
        # train()
        verify_modle()

使用图像3导入模型结果为：

![20200803200155783.png][]

最后有几点需要注意。

**1.我这里写的是很简单的0-9手写数字试别，所以再构建输入的时候只有一个输入通道，如果是复杂的问题，可能需要多个输入通道，比如彩色的图像，可能需要R,G,B三个输入通道。**

**        2.训练AI是这么个过程，给定输入，给定输入，让AI像人一样去学习。就像一个人要学习一样，告诉自己，这个图像3输入的结果是3。是一定要给出输出的。**

**        3.AI模型就像我们以前写的函数，给了输入，它就会给输出。像这个0-9的输入是为数字0-9的概率。而不是直接告诉你是什么数字，取出最大的概率对应的数字，就是AI觉得这张图是个什么数字.**

**        4.我也是初学者，写的注释什么的都是自己的理解，可能不对。如果有发现错误的/有歧义的地方。欢迎指出**

**5.上面的训练就是不断利用卷积神经网络提取各种图像的特征，最后当给定一副新的图，就去匹配其相应的特征，给出结果。**

增加一些知识补充连接：

1.知乎<如何通俗易懂的理解卷积> https://www.zhihu.com/question/22298352/answer/228543288  
        2.卷积神经网络详解 - 卷积层逻辑篇  https://blog.csdn.net/tjlakewalker/article/details/83275322

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhbmZ1c2hlbjAwNw_size_16_color_FFFFFF_t_70]: /images/20230208/ae549ce063ce4ad9a5fc7c225c1d7438.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhbmZ1c2hlbjAwNw_size_16_color_FFFFFF_t_70 1]: /images/20230208/188d464a8cf3454e9e77123c0a3eb09a.png
[20200803200155783.png]: /images/20230208/b130a0cf27f94fc798a8a3a9ef8e9841.png