《深度学习入门》3.6手写数字识别代码分析

 

代码块1：读入MNIST数据

p70duruMNIST.py：

import sys, os
sys.path.append(os.pardir) # 为了导入父目录中的文件而进行的设定
from dataset.mnist import load_mnist
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True,
normalize=False)
print(x_train.shape)
print(t_train.shape) 
print(x_test.shape) 
print(t_test.shape)

分析：

import sys, os

导入os模块与sys模块
os模块：提供系统级别的操作
sys模块：提供解释器相关的操作
参考：https://blog.csdn.net/qq_42874945/article/details/81911931
==================================================

sys.path.append(os.pardir)

为了导入父目录中的文件而进行的设定。

参考：https://www.ituring.com.cn/book/tupubarticle/21862

用来读入 MNIST 图像的文件在本书提供的源代码的 dataset 目录下。并且，我们假定了这个 MNIST 数据集只能从 ch01、ch02、ch03、…、ch08 目录中使用，因此，使用时需要从父目录（dataset 目录）中导入文件，为此需要添加 sys.path.append(os.pardir) 语句。

观察本书源代码可知，上述代码在 mnist_show.py 文件中。mnist_show.py 文件的当前目录是 ch03，但包含 load_mnist()函数的 mnist.py 文件在 dataset 目录下。因此，mnist_show.py 文件不能跨目录直接导入 mnist.py 文件。sys.path.append(os.pardir) 语句实际上是把父目录 deep-learning-from-scratch 加入到 sys.path（Python 的搜索模块的路径集）中，从而可以导入 deep-learning-from-scratch 下的任何目录（包括 dataset 目录）中的任何文件。——译者注

已知sys.path返回的是一个列表

python列表（参考：https://www.runoob.com/python/python-lists.html）：

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]

list2 = [1, 2, 3, 4, 5 ]

list3 = ["a", "b", "c", "d"]

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

 本机中测试sys.path的测试结果如下：

import sys
print(sys.path)

#运行结果
['F:\\学习代码\\深度学习\\深度学习入门：基于Python的理论与实现\\【源代码】深度学习入门：基于Python的理论与实现\\ch03', 'C:\\ProgramData\\Anaconda3\\python37.zip', 'C:\\ProgramData\\Anaconda3\\DLLs', 'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin']

***Repl Closed***

可知sys.path 返回的是一个列表，该路径已经添加到系统的环境变量了，当我们要添加自己的搜索目录时，可以通过列表的append()方法；

对于模块和自己写的脚本不在同一个目录下，在脚本开头加sys.path.append('引用模块的地址’)。

但是这种方法是运行时修改，脚本运行后则失效（参考：https://www.jianshu.com/p/4b71e9007a7e）。

关于Python3中os.pardir和sys.path的用法（参考：https://www.jianshu.com/p/72aec679422e）

1、通常，在python中，os模块和sys模块共同为我们提供了大多数面向系统、文件、解释器等较底层的接口。

2、os.pardir会返回父集目录'..'，os.curdir会返回当前目录'.'。

3、sys.path会返回解释器寻找目标的地址，通常' '是第一个参数，代表该代码所在目录

4、如果我们想要把不在sys.path返回路径的包import进入我们的代码，无非有以下方法：

    A.复制一份包到解释器路径下

    B.在解释器路径末尾添加包的位置，在之前的任何路径都没有发现包时，会从此处寻找

 ================================================================================================

from dataset.mnist import load_mnist

打开dataset文件夹中的mnist.py模块并导入其中的load_mnist类

def load_mnist(normalize=True, flatten=True, one_hot_label=False):
    """读入MNIST数据集
    
    Parameters
    ----------
    normalize : 将图像的像素值正规化为0.0~1.0
    one_hot_label : 
        one_hot_label为True的情况下，标签作为one-hot数组返回
        one-hot数组是指[0,0,1,0,0,0,0,0,0,0]这样的数组
    flatten : 是否将图像展开为一维数组
    
    Returns
    -------
    (训练图像, 训练标签), (测试图像, 测试标签)
    """
    if not os.path.exists(save_file):
        init_mnist()
        
    with open(save_file, 'rb') as f:
        dataset = pickle.load(f)
    
    if normalize:
        for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].astype(np.float32)
            dataset[key] /= 255.0
            
    if one_hot_label:
        dataset['train_label'] = _change_one_hot_label(dataset['train_label'])
        dataset['test_label'] = _change_one_hot_label(dataset['test_label'])
    
    if not flatten:
         for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].reshape(-1, 1, 28, 28)

    return (dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label']) 

================================================================================================

(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
load_mnist（）函数中设置了默认值，没特意写one-hot_label的实参值就代表使用默认值False。（p《Python编程从入门到实践》118页附近）

 

代码块2：显示MNIST图像

mnist_show.py

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist#打开dataset文件夹下的mnist.py模块并导入其中的load_mnist方法
from PIL import Image#导入模块PIL中的Image方法

#该函数仅为了把图片展示出来，别的也没啥用
def img_show(img):
    #把保存在Numpy数组的图像数据转换成PIL用的数据对象。
    pil_img = Image.fromarray(np.uint8(img))
    #显示图片
    pil_img.show()

#以下是看看这第一个图像的真面目
#展开输入图像为一维数组并正规化
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

#将训练图像的第一个数据赋值给img（大小为28*28像素=784）
img = x_train[0]
#将训练标签的第一个数据赋值给label
label = t_train[0]
print(label)  # 第一个数据标签是5
print(img.shape)  # 第一个图像的形状是(784,)

img = img.reshape(28, 28)  # 把图像的形状变为原来的（28*28）尺寸，更改numpy数组的形状
print(img.shape)  # (28, 28)

img_show(img)

分析：

pil_ pil_img = Image.fromarray(np.uint8(img))

把保存在Numpy数组的图像数据转换成PIL用的数据对象。

PIL中的Image和numpy中的数组array相互转换（参考：https://www.jianshu.com/p/18dabefa6778）

array转换成image

from PIL import Image
Image.fromarray(np.uint8(img))

注意img如果是uint16的矩阵而不转为uint8的话，Image.fromarray这句会报错:

File "/usr/local/lib/python2.7/site-packages/PIL/Image.py", line 1884, in fromarray
raise TypeError("Cannot handle this data type")
TypeError: Cannot handle this data type

uint8: uint8是无符号八位整型，表示范围是[0, 255]的整数（我猜是因为这里图片的像素就是0~255？）

uint16:无符号的16位整型

什么是有符号数和无符号数（参考：https://zhidao.baidu.com/question/147776732.html）

有符号数就是用最高位表示符号（正或负），其余位表示数值大小，无符号数则所有位都用于表示数的大小。

有符号数和无符号数是针对二进制来讲的。

 ================================================================================================

img = img.reshape(28, 28)  

把图像的形状变为原来的（28*28）尺寸，更改numpy数组的形状。

Python numpy函数：reshape（）

reshape（）是数组对象中的方法，用于改变数组的形状。

形状变化是基于数组元素个数不能改变的，变成的新形状中所包含的元素个数必须符合原来元素个数。如果数组元素发生变化的时候，就会报错：

reshape函数生成的新数组和原始数组公用一个内存，也就是说，不管是改变新数组还是原始数组的元素，另一个数组也会随之改变：

————————————————
版权声明：本文为CSDN博主「Daisy_HJL」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_28618765/article/details/78083895

代码块3：实现神经网络的推理处理

neuralnet_mnist.py:

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax

#用这3个函数来实现神经网络的推理处理。
#然后评价它的识别精度（accuracy），即能在多大程度上正确分类。

#获取测试图像和测试标签
def get_data():
    #将图像正规化为0.0~1.0的值；将图像展开为一维数组；像7、2这样简单保存正确解标签
    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
    return x_test, t_test

#init_network()会读入保存在pickle文件sample_weight.pkl中的学习到的权重参数。
#这个文件中以字典变量的形式保存了权重和偏置参数。
def init_network():
    #打开文件sample_weight.pkl
    #'rb'以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)#打印network可知是W1,b2,W2...之类的参数,network是字典。
    return network

#predict()函数以NumPy数组的形式输出各个标签对应的概率。
#比如输出 [0.1, 0.3, 0.2, ..., 0.04]的数组，该数组表示“0”的概率为 0.1，“1”的概率为 0.3，等等。#然后，我们取出这个概率列表中的最大值的索引（第几个元素的概率最高），作为预测结果。
def predict(network, x):
    #network中的数据是以字典保存的
    #W1的shape是(784,50),W2的shape是(50,100),W3的shape是(100,10)
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    
    #第一层隐藏函数的输入
    a1 = np.dot(x, W1) + b1
    #第一层隐藏函数的输出
    z1 = sigmoid(a1)

    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    
    #输出层的输入
    a3 = np.dot(z2, W3) + b3
    #softmax的结果是返回属于各个类别概率大小的数组,是一个元素个数为10的一维数组
    y = softmax(a3)

    return y

#获取测试图像和测试标签，x的shape是(10000,784)
x, t = get_data()
#生成网络
network = init_network()
#初始精度为0
accuracy_cnt = 0

#用for循环语句逐一取出测试图像
for i in range(len(x)):
    #得到x[i]的预测结果y,x[i]的shape是(784,)
    y = predict(network, x[i]) 
    #获取预测结果数组中概率最高的元素的索引
    p= np.argmax(y) 
    #判断预测结果是否和测试标签相同
    if p == t[i]:
        #相同则正确数+1
        accuracy_cnt += 1

#精确度=正确数/总数据个数
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

代码块3：（基于批处理）实现神经网络的推理处理

neuralnet_mnist_batch.py:

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax


def get_data():
    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
    return x_test, t_test


def init_network():
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)
    return network


def predict(network, x):
    w1, w2, w3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, w1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, w2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, w3) + b3
    y = softmax(a3)

    return y

#前面都一样的

x, t = get_data()
network = init_network()

batch_size = 100 # 批数量
accuracy_cnt = 0

#range()函数若指定为range(start, end)，则会生成一个由start到end-1之间的整数构成的列表。
#若像range(start, end, step)这样指定3个整数，则生成的列表中的下一个元素会增加step指定的值。
#本例中是像x[0:100]、x[100:200]……这样，从头开始以100为单位将数据提取为批数据。
for i in range(0, len(x), batch_size):
    x_batch = x[i:i+batch_size]
    #x_batch的shape是(100,784)
    #y_batch的shape是(100,10)，是神经网络的输出数组
    y_batch = predict(network, x_batch)

    #通过 argmax()获取值最大的元素的索引。
    #给定参数axis=1：指定在 100 × 10的数组中，沿着第1维方向找到值最大的元素的索引
    #第1维是行方向，第0维是列方向
    #第0维对应第1个维度（好混乱啊晕了@_@）
    #p是神经网络输出数组中的最大值所组成的数组，它的shape应该是(100,)
    p = np.argmax(y_batch, axis=1)
    #p == t[i:i+batch_size]：
    #在NumPy数组之间使用比较运算符（==）生成由True/False构成的布尔型数组
    #并计算数组中True的个数,即比较这一批输出数据有哪些是正确的。
    accuracy_cnt += np.sum(p == t[i:i+batch_size])

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))