基于Python实现的手写数字图像识别

目录
实验目的及实验内容 1
实验目的： 1
实验内容： 1
原理分析： 1
实验环境 13
实验步骤及实验过程分析 13
实验结果总结 18
实验目的及实验内容
（本次实验所涉及并要求掌握的知识；实验内容；必要的原理分析）
实验目的：
使用 python 进行图像处理
实验内容：
自己找一张图片，用 OpenCV 的仿射变换实现图片缩放。
理解 HOG、ORC 过程，修改 digits.py 或独立编程，实现数字图像的识别，要求分别使用 SVM、knn（第六次课）以及 cnn 神经网络模型（第七次课），以群文件中 digit_data.rar 中 train 文件夹下数据作为训练集，test 文件夹下图片作为测试集，并计算测试集上分类正确率，本文转载自http://www.biyezuopin.vip/onews.asp?id=16706并自己找测试数据（可以是一个或多个数字）。
实验环境
（本次实验所使用的器件、仪器设备等的情况）
处理器：Intel® Core™ i5-9300H CPU @ 2.40GHz 2.40 GHz (2)操作系统环境：Windows 10 家庭中文版 x64 19042.867
编程语言：Python 3.8
其他环境：16 GB 运行内存
IDE 及包管理器：JetBrains PyCharm 2020.1 x64， anaconda 3 for Windows（conda 4.9.0）
实验步骤及实验过程分析
（详细记录实验过程中发生的故障和问题，进行故障分析，说明故障排除的过程及方法。根据具体实验，记录、整理相应的数据表格、绘制曲线、波形等）
说明：
本篇实验报告所记录的内容仅为写报告时（2021/05/12）的情况，可能与实际实验时/04/28）结果有出入。
一切以实际运行时所得到的结果为准。
用 OpenCV 的仿射变换实现图片缩放：

import numpy as np
import torch
from torch import nn
import torch.nn.functional as F
import pickle
from utils import label_2_id, id_2_label
from torch.utils.data import TensorDataset, DataLoader
import matplotlib.pyplot as plt
import cv2 as cv
import os


class CnnImage(object):
    def __init__(self, data_dir='../digit_data', save_dir='./data', batch_size=64,
                 epochs=50, learning_rate=0.0005, use_gpu=False):
        self.data_dir = data_dir
        self.mode = 'train'
        self.save_dir = save_dir
        self.batch_size = batch_size
        if not use_gpu:
            self.device = torch.device("cpu")
            print('use device: cpu')
        else:
            self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
            if self.device == torch.device("cpu"):
                print('no usable cuda detected! Use cpu instead')
            else:
                print('use device: gpu')
        self.epochs = epochs
        self.lr = learning_rate
        self.loss_ = []
        if not os.path.exists(self.save_dir):
            os.mkdir(self.save_dir)

        self.model = nn.Sequential(nn.Conv2d(1, 25, 3, 1),
                                   nn.MaxPool2d(2, 2),
                                   nn.Conv2d(25, 50, 3, 1),
                                   nn.MaxPool2d(2, 2),
                                   nn.Flatten(),
                                   nn.Linear(50 * 5 * 5, 10))
        self.model.to(self.device)
        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr)

    def train(self, train_loader, test_loader, save=True):
        best_test = None
        tmp_loss = []
        best_model = self.model
        for epoch in range(self.epochs):
            for batch, label in train_loader:
                y_predict = self.model(batch)
                loss = F.cross_entropy(y_predict, label)
                tmp_loss.append(loss.item())
                loss.backward()
                self.optimizer.step()
                self.optimizer.zero_grad()

            self.loss_.append(sum(tmp_loss)/len(tmp_loss))

            correct_percent = 0
            error_num = 0
            with torch.no_grad():
                for batch, label in test_loader:
                    y_predict = self.model(batch)
                    top_p, top_class = torch.topk(y_predict, 1)
                    top_class = top_class.squeeze(1)
                    correct_percent += torch.sum(label == top_class).item()
                    error_num += torch.sum(label != top_class).item()
            correct_percent /= len(test_loader) * self.batch_size

            if best_test is None or best_test < correct_percent:
                best_test = correct_percent
                best_model = self.model

        self.model = best_model
        if save:
            tar = self.save_dir + '/' + 'model_cnn.pkl'
            with open(tar, 'wb') as f:
                pickle.dump(self.model, f)
            print('model saved successfully, see it in: ', tar)

        print('训练出的最好的模型在测试集上的正确率: ' + str(best_test))

    def load_model(self):
        tar = self.save_dir + '/' + 'model_cnn.pkl'
        with open(tar, 'rb') as f:
            self.model = pickle.load(f)
        print('model loaded successfully!')

    def predict(self, path):
        if os.path.isdir(path):
            files = os.listdir(path)
        else:
            print('no files detected!')
            return None
        x = []
        y = []
        for item in files:
            file = path + '/' + item
            img = cv.imread(file, 0)  # 读灰度图
            re_shape = cv.resize(img, (28, 28), interpolation=cv.INTER_CUBIC)
            # shape: (28, 28), size of the reshaped image
            x.append(re_shape)
            y.append(0)
        x_set = np.array(x)
        # array, shape:(n, 28, 28)
        y_set = np.array(y)
        # array, shape:(n,)
        x_tens = torch.tensor(x_set, dtype=torch.float).unsqueeze(1).to(self.device)
        y_tens = torch.tensor(y_set, dtype=torch.long).to(self.device)
        # x_tens: torch.Tensor, torch.Size([n, 1, 28, 28])
        # y_tens: torch.Tensor, torch.Size([n])
        sets = TensorDataset(x_tens, y_tens)
        loader = DataLoader(sets, self.batch_size, True)
        with torch.no_grad():
            for batch, label in loader:
                y_predict = self.model(batch)
                top_p, top_class = torch.topk(y_predict, 1)
                top_class = top_class.squeeze(1)
        return top_class.cpu().tolist()  # 返回的结果在CPU上， 是个列表

    def set_data(self, save=True):
        sets = self.save_dir + '/sets.pkl'
        if os.path.exists(sets):
            with open(sets, 'rb') as f:
                loader = pickle.load(f)
            train_loader = loader[0]
            test_loader = loader[1]
            print('dataset loaded successfully!')
        else:
            self.mode = 'train'
            train_dataset = self.dataset()
            train_loader = DataLoader(train_dataset, self.batch_size, True)
            self.mode = 'test'
            test_dataset = self.dataset()
            test_loader = DataLoader(test_dataset, self.batch_size, True)
            print('dataset built successfully!')

            if save:
                loader = (train_loader, test_loader)
                with open(sets, 'wb') as f:
                    pickle.dump(loader, f)
                print('dataset saved in: ', sets)
        return train_loader, test_loader

    def dataset(self):
        path = self.data_dir + '/' + self.mode
        labels = os.listdir(path)
        x = []
        y = []
        for label in labels:
            img_path = path + '/' + label
            files = os.listdir(img_path)
            for item in files:
                file = img_path + '/' + item
                img = cv.imread(file, 0)  # 读灰度图
                # shape: (28, 28), size of the image
                x.append(img)
                y.append(label_2_id[label])
        x_set = np.array(x)
        # array, shape:(n, 28, 28)
        x_tens = torch.tensor(x_set, dtype=torch.float).unsqueeze(1).to(self.device)
        # torch.Tensor, torch.Size([n, 1, 28, 28])
        y_set = np.array(y)
        # array, shape:(n,)
        y_tens = torch.tensor(y_set, dtype=torch.long).to(self.device)
        # torch.Tensor, torch.Size([n])
        sets = TensorDataset(x_tens, y_tens)
        return sets


def train_():
    epochs = 100
    cnn = CnnImage(data_dir='../digit_data', save_dir='./data', batch_size=64,
                   use_gpu=True, epochs=epochs, learning_rate=0.0005)
    train_loader, test_loader = cnn.set_data(save=True)
    cnn.train(train_loader=train_loader, test_loader=test_loader, save=True)
    loss = cnn.loss_

    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.set_title('epoch - loss')
    ax.set_xlabel('epoch')
    ax.set_ylabel('loss')
    x_axis = [i for i in range(len(loss))]
    plt.plot(x_axis, loss)
    plt.show()


def test():
    cnn = CnnImage(data_dir='../digit_data', save_dir='./data', batch_size=64,
                   use_gpu=True)
    cnn.load_model()
    test_path = 'testimg'
    pre = cnn.predict(test_path)
    if pre is None:
        return
    else:
        files = os.listdir(test_path)
        for i in range(len(files)):
            res = files[i] + ' 的预测结果为: ' + str(pre[i])
            print(res)


if __name__ == '__main__':
    train_()
    test()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209