手写数字识别

分手后的思念是犯贱 2021-12-21 13:23 390阅读 0赞

#### 1. 创建、训练和查询3层神经网络： ####

import numpy as np
    import matplotlib.pyplot as plt
    import scipy.special as spp
    class Ann2020:
        # 初始化神经网络
        def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
            # 设置每个输入层、隐藏层和输出层的节点数
            self.inodes = inputnodes
            self.hnodes = hiddennodes
            self.onodes = outputnodes
    
            # 链接权重矩阵，wih和who
            # 数组中的权值为w_i_j，其中链接是从下一层的节点i到节点j
            # w11 w21
            # w12 w22 etc
            self.wih = np.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))
            self.who = np.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))
    
            # 学习率
            self.lr = learningrate
    
            # 激活函数
            self.activation_function = lambda x: spp.expit(x)
    
            pass
    
        # 训练神经网络
        def train(self, inputs_list, targets_list):
            # convert inputs list to 2d array
            inputs = np.array(inputs_list, ndmin=2).T
            targets = np.array(targets_list, ndmin=2).T
    
            # 计算信号到隐藏层
            hidden_inputs = np.dot(self.wih, inputs)
            # 计算从隐层发出的信号
            hidden_outputs = self.activation_function(hidden_inputs)
    
            # 将信号计算到最终的输出层
            final_inputs = np.dot(self.who, hidden_outputs)
            # 计算最终输出层发出的信号
            final_outputs = self.activation_function(final_inputs)
    
            # 输出层误差为(目标-实际)
            output_errors = targets - final_outputs
            # 隐藏层错误是output_errors，按权重拆分，在隐藏节点上重新组合
            hidden_errors = np.dot(self.who.T, output_errors)
    
            # 更新隐藏层和输出层之间链接的权重
            self.who += self.lr * np.dot((output_errors * final_outputs * (1.0 - final_outputs)),
                                         np.transpose(hidden_outputs))
    
            # 更新输入层和隐藏层之间链接的权重
            self.wih += self.lr * np.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)),
                                         np.transpose(inputs))
    
            pass
    
        # 查询神经网络
        def query(self, inputs_list):
            # 将输入列表转换为2d数组
            inputs = np.array(inputs_list, ndmin=2).T
    
            # 计算信号到隐藏层
            hidden_inputs = np.dot(self.wih, inputs)
            # 计算从隐层发出的信号
            hidden_outputs = self.activation_function(hidden_inputs)
    
            # 将信号计算到最终的输出层
            final_inputs = np.dot(self.who, hidden_outputs)
            # 计算最终输出层发出的信号
            final_outputs = self.activation_function(final_inputs)
    
            return final_outputs
    
    
    # 输入、隐藏和输出节点的数量
    input_nodes = 784
    hidden_nodes = 200 #最佳可调整至500
    output_nodes = 10
    # 学习率为 0.3
    learning_rate = 0.1
    # 创建神经网络实例
    n = Ann2020(input_nodes, hidden_nodes, output_nodes, learning_rate)
    # 测试查询(目前还没有任何有用的含义)
    
    f = np.load('mnist.npz')
    x_train, y_train = f['x_train'], f['y_train']
    x_test, y_test = f['x_test'], f['y_test']
    f.close()
    epochs = 5
    for e in range(epochs):
        # 遍历所有数据
        for record,y_trainn in zip(x_train,y_train):
            # 缩放输入值
            inputs = (np.asfarray(record[:]).ravel() / 255.0 * 0.99) + 0.01
            # 创建目标输出值(除所需的标签为0.99外，其余均为0.01)
            targets = np.zeros(output_nodes) + 0.01
            # 记录标签
            targets[int(y_trainn)] = 0.99
            n.train(inputs, targets)
            pass
        pass
    
    scorecard = []
    for record,y_testn in zip(x_test,y_test):
        # 导入标签
        correct_label = int(y_testn)
        # 预处理输入
        inputs = (np.asfarray(record[:]).ravel() / 255.0 * 0.99) + 0.01
        # 查询神经网络
        outputs = n.query(inputs)
        # 将最大值的索引对应到标签
        label = np.argmax(outputs)
        # 将识别分数添加进列表
        if (label == correct_label):
            # 匹配 计1
            scorecard.append(1)
        else:
            # 不匹配 计0
            scorecard.append(0)
            pass
    
        pass
    
    scorecard_array = np.asarray(scorecard)
    print ("准确率 = ", scorecard_array.sum() / scorecard_array.size)

###### 准确率高达98% ######

#### 2. 自制自己的手写数字图像进行测试： ####

我所使用的手机拍摄图片：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjg5NzM2_size_16_color_FFFFFF_t_70]

#### 自制图像的去噪与黑白转换代码： ####

# -*- coding: utf-8 -*-
    # 图像去噪并转化为黑白图像
    import os
    from PIL import Image
    
    curdir = "F:\\pyth\\shendu\\CNN2019\\image"
    
    os.chdir(curdir)
    
    
    def RGB2B(filename):
        im = Image.open(filename)
        print("image info,", im.format, im.mode, im.size)
        (w, h) = im.size
        R = 0
        G = 0
        B = 0
    
        for x in range(w):
            for y in range(h):
                pos = (x, y)
                rgb = im.getpixel(pos)
                (r, g, b) = rgb
                R = R + r
                G = G + g
                B = B + b
    
        rate1 = R * 1000 / (R + G + B)
        rate2 = G * 1000 / (R + G + B)
        rate3 = B * 1000 / (R + G + B)
    
        print("rate:", rate1, rate2, rate3)
    
        for x in range(w):
            for y in range(h):
                pos = (x, y)
                rgb = im.getpixel(pos)
                (r, g, b) = rgb
                n = r * rate1 / 1000 + g * rate2 / 1000 + b * rate3 / 1000
                # print "n:",n
                if n >= 155:
                    im.putpixel(pos, (255, 255, 255))
                else:
                    im.putpixel(pos, (0, 0, 0))
    
        im.save('my_image3_whiteb.png')
    
    
    def saveAsBmp(fname):
        pos1 = fname.rfind('.')
        fname1 = fname[0:pos1]
        fname1 = fname1 + '_hui.png'
        im = Image.open(fname)
        new_im = Image.new("RGB", im.size)
        new_im.paste(im)
        new_im.save(fname1)
        return fname1
    
    
    if __name__ == "__main__":
        filename = saveAsBmp("my_image3.png")
        RGB2B(filename)

#### 将测试部分转换为自己的图像测试： ####

our_own_dataset = []
    
    # 获得测试图像信息
    for image_file_name in glob.glob('my_image?.png'):
        # 使用倒数第五个字符作为正确标签
        label = int(image_file_name[-5:-4])
    
        # 获得图像
        print("loading ... ", image_file_name)
        img_array = imageio.imread(image_file_name, as_gray=True)
    
        # 转化为一维数组 并反转
        img_data = 255.0 - img_array.reshape(784)
    
        # 把像素值转为到0.01到0.99之间
        img_data = (img_data / 255.0 * 0.99) + 0.01
        print(np.min(img_data))
        print(np.max(img_data))
    
        # 添加图像标签和信息到列表
        record = np.append(label, img_data)
        our_own_dataset.append(record)
    
        pass
    
    item = 3
    
    # 画出图像
    plt.imshow(our_own_dataset[item][1:].reshape(28,28), cmap='Greys', interpolation='None')
    
    #拿到正确标签
    correct_label = our_own_dataset[item][0]
    # data is remaining values
    inputs = our_own_dataset[item][1:]
    
    # 查询神经网络
    outputs = n.query(inputs)
    print (outputs)
    
    # 与输出最高的得分标签进行比较
    label = np.argmax(outputs)
    print("机器判断为：", label)
    # 输出判断正误
    if (label == correct_label):
        print ("识别正确!")
    else:
        print ("识别错误!")
        pass
    
    plt.show()

#### 效果展示： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjg5NzM2_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjg5NzM2_size_16_color_FFFFFF_t_70]: /images/20211220/cc031b78791e40e0a7424cc8443fe4a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjg5NzM2_size_16_color_FFFFFF_t_70 1]: /images/20211220/7ba2bc767adb4fae8c41ec989eb2620b.png