（一）数据处理

1.图像增强：

from keras.preprocessing import image
import os
import matplotlib.pyplot as plt
import numpy as np
from imageio import imwrite

"""
数据增强实现
将 1084 张图片扩为 1084*80 张
"""

# 常量
im_h = 46       # 图片高度
im_w = 120      # 图片宽度
im_chan = 3     # 图片通道数目
im_n = 4        # 每张图片分割的子图数目
w = 30          # 分割图片宽度，为im_w的四分之一


def load_img_t(path):
    """
    加载完整的一张图片
    origin: (43, 120, 3)
    target: (1, 43, 120, 3)
    :param path: 图片路径
    :return:
    """
    im = plt.imread(path)
    im.resize(im_h, im_w, im_chan)       # 压缩成标准尺寸
    x = np.zeros((1, im_h, im_w, im_chan))
    x[0] = im
    return x


def splice_img(arr):
    """
    拼接图片
    origin: (4, 43, 30, 3)
    target: (43, 120, 3)
    :param arr: 四张子图片数组
    :return:
    """
    im = np.zeros((im_h, im_w, im_chan))
    for i in range(im_n):
        im[:, i*w:(i+1)*w, :] = arr[i]
    return im


def load_img(path):
    """
    加载某张图片，每张分割成四张图片，返回x数组
    origin: (43, 120, 3)
    target: (4, 43, 30, 3)
    :param path: 图片路径
    :return:
    """
    im = plt.imread(path)
    im.resize(im_h, im_w, im_chan)       # 压缩成标准尺寸
    x = np.zeros((im_n, im_h, w, im_chan))        # 分割成四张图片
    for i in range(im_n):
        x[i] = im[:, i*w:(i+1)*w, :]
    return x


im_dir = '../../data/images/'
im_aug_dir = '../../data/images_aug/'

files = os.listdir(im_dir)

n = 10

# 1 - 10
# 缩放与旋转
im_gen1 = image.ImageDataGenerator(zoom_range=[2, 1], rotation_range=40)

for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen1.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1) + '.png', splice_img(im_iter.next()))

# 11 - 20
im_gen2 = image.ImageDataGenerator(samplewise_center=True,
                                   samplewise_std_normalization=True)
for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen2.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n) + '.png', splice_img(im_iter.next()))

# 21 - 30
im_gen3 = image.ImageDataGenerator(shear_range=0.5)
for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen3.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*2) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*2) + '.png', splice_img(im_iter.next()))

# 31 - 40
im_gen4 = image.ImageDataGenerator(channel_shift_range=0.2)
for file in files:
    im = load_img_t(os.path.join(im_dir, file))
    im_iter = im_gen4.flow(im, batch_size=1, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*3) + '.png', im_iter.next()[0])
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*3) + '.png', im_iter.next()[0])

# 41 - 50
im_gen5 = image.ImageDataGenerator(zoom_range=[2, 1])

for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen5.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*4) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*4) + '.png', splice_img(im_iter.next()))

# 51 - 60
im_gen6 = image.ImageDataGenerator(rotation_range=40)

for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen6.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*5) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*5) + '.png', splice_img(im_iter.next()))

# 61 - 70
im_gen7 = image.ImageDataGenerator(zoom_range=[1.5, 1], channel_shift_range=0.1)

for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen7.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*6) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*6) + '.png', splice_img(im_iter.next()))

# 71 - 80
im_gen8 = image.ImageDataGenerator(rotation_range=30, channel_shift_range=0.1)

for file in files:
    im = load_img(os.path.join(im_dir, file))
    im_iter = im_gen8.flow(im, batch_size=4, shuffle=False)
    for i in range(n):
        imwrite(im_aug_dir + file[:-5] + str(i+1+n*7) + '.png', splice_img(im_iter.next()))
        # plt.imsave(im_aug_dir + file[:-5] + str(i+1+n*7) + '.png', splice_img(im_iter.next()))

2.图像灰度化

from imageio import imwrite
import matplotlib.pyplot as plt
import os

"""
将所有rgb图片转换成灰度图，放入 /data/images_gray/ 中
"""


def rgb2gray(rgb):
    """
    将rgb图转换为灰度图
    :param rgb:
    :return:
    """
    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
    return gray


im_dir = '../../data/images/'
im_aug_dir = '../../data/images_aug/'
im_gray_dir = '../../data/images_gray/'


files = os.listdir(im_dir)
for file in files:
    im = plt.imread(os.path.join(im_dir, file))
    imwrite(im_gray_dir + file, rgb2gray(im))


files = os.listdir(im_aug_dir)
for file in files:
    im = plt.imread(os.path.join(im_aug_dir, file))
    imwrite(im_gray_dir + file, rgb2gray(im))

 模型训练与预测：

 （二）pytorch写法：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import torch
import os
import torch.utils.data as Data
import torch.nn as nn
from torch.autograd import Variable
import torch.nn.functional as F

learning_rate = 0.02
batch_size=256
num_epochs = 20
num_classes=1
"""
图片处理与数据加载相关工具方法
"""

# 数字列表
digit_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '']

# 常量
im_h = 46       # 图片高度
im_w = 120      # 图片宽度
im_chan = 3     # 图片通道数目
im_chan_2 = 4   # 图片通道数目
im_n = 4        # 每张图片分割的子图数目
w = 30          # 分割图片宽度，为im_w的四分之一

######################################################################
def load_dir_img(path):
    """加载目录下所有的灰度图片，每张分割成四张图片，返回x数组和y标签数组"""
    files = os.listdir(path)
    # print('files',files)
    #一张训练图片有4张可以分割的图片
    x = np.zeros((len(files)*im_n, im_h, w))
    #分割的图片是原先训练图片的4倍，产生四倍标签
    y = np.zeros(len(files)*im_n)
    for i in range(len(files)):
        file_path = os.path.join(path, files[i])
        im = plt.imread(file_path)
        labels = []
        for k in files[i][0:im_n]:
            if k == '_':
                labels.append(10)
            else:
                labels.append(int(k))
        #切割图片然后将1/4的图片赋值给x
        for j in range(im_n):
            x[i*im_n+j] = im[:, j*w:(j+1)*w]
            y[i*im_n+j] = labels[j]
    return x, y
def load_data_2(img_dir=r'../../data/images_gray', npz_path='../../data/digits.npz'):
    """加载目录下所有图片，自动分成训练集和测试集"""
    x, y = load_dir_img(img_dir)
    # print('load images finished')
    #将图片分为x_train,y_train,将标签分为y_train,y_test
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=42)
    np.savez(npz_path, x_train=x_train, y_train=y_train, x_test=x_test, y_test=y_test)
    # print('data saved as ', npz_path)
    return (x_train, y_train), (x_test, y_test)


def load_data_3(path='../../data/digits.npz'):
    """加载已保存的数据"""
    if os.path.exists(path):
        print('load saved data')
        with np.load(path) as f:
            x_train, y_train = f['x_train'], f['y_train']
            x_test, y_test = f['x_test'], f['y_test']
        return (x_train, y_train), (x_test, y_test)
    else:
        print('initial load data')
        return load_data_2(npz_path=path)
#多分类标签label 转换为 one-hot
def dense_to_one_hot(labels_dense, num_classes):
    """Convert class labels from scalars to one-hot vectors."""
    num_labels = labels_dense.shape[0]
    index_offset = np.arange(num_labels) * num_classes
    labels_one_hot = np.zeros((num_labels, num_classes))
    labels_one_hot.flat[index_offset+labels_dense.ravel()] = 1
    return labels_one_hot

def setdata():
    (x_train, y_train), (x_test, y_test) = load_data_3()
    x_train = x_train[:, np.newaxis, :, :]
    x_train=torch.from_numpy(x_train)
    x_train = x_train.type(torch.FloatTensor)  # 转LongTensor
    # print(x_train.shape)
    y_train = y_train.astype(np.int64)
    # y_train = dense_to_one_hot(y_train, 11)
    # print(y_train)
    # y_train = y_train.astype(np.int64)
    y_train=torch.from_numpy(y_train)
    # print(y_train.shape)
    # print('ay_train', y_train.shape)


    x_test = x_test[:, np.newaxis, :, :]
    x_test=torch.from_numpy(x_test)
    x_test = x_test.type(torch.FloatTensor)  # 转LongTensor

    y_test = y_test.astype(np.int64)
    # y_test = dense_to_one_hot(y_test, num_classes)
    # y_test = y_test.astype(np.int64)
    y_test=torch.from_numpy(y_test)
    # print('y_test', y_test)
    train_dataset = Data.TensorDataset(x_train, y_train)
    test_dataset = Data.TensorDataset(x_test, y_test)
    return  train_dataset,test_dataset
####################################################
#########数据集构建#########
train_dataset,test_dataset=setdata()
train_loader=Data.DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True)
test_loader=Data.DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=True)
####################################################
# 将数据处理成Variable, 如果有GPU, 可以转成cuda形式
def get_variable(x):
    x = Variable(x)
    return x.cuda() if torch.cuda.is_available() else x

def get_test_variable(x):
    with torch.no_grad():
        x = Variable(x)
    return x.cuda() if torch.cuda.is_available() else x

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=5, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True)
        )

        self.layer2 = nn.Sequential(
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Dropout(0.25),
        )

        self.layer3 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=5),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True)
        )

        self.layer4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Dropout(0.5),
        )

        self.fc = nn.Sequential(
            nn.Linear(2880, 256),
            nn.ReLU(inplace=True),
            # nn.Dropout(0.5),
            nn.Linear(256, 84),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(84, 11),
        )

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

import time
# model = CNN()
model=torch.load("cnn1.pkl")
# model = torch.load('cnn1.pkl')
model.cuda()
##### 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

### 训练模型

print('************************模型训练开始************************')
start = time.process_time()
step = 0  # 步数，可用下面的 i
for i in range(num_epochs):
    for data in train_loader:
        img, label = data
        # img = img.view(img.size(0), -1)
        img = Variable(img)
        if torch.cuda.is_available():
            img = img.cuda()
            label = label.cuda()
        else:
            img = Variable(img)
            label = Variable(label)
        out = model(img)
        loss = criterion(out, label)
        print_loss = loss.data.item()

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        step += 1
        print('steps: {}, loss: {:.4}'.format(step, print_loss))

print('************************模型训练结束************************')
end = time.process_time() - start
print('模型耗时：{:.2f}/s'.format(end))

# 保存模型
torch.save(model, 'cnn1.pkl')

# 模型评估
# model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
    img, label = data
    # img = img.view(img.size(0), -1)
    img = Variable(img)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()

    out = model(img)
    loss = criterion(out, label)
    eval_loss += loss.data.item() * label.size(0)
    _, pred = torch.max(out, 1)
    num_correct = (pred == label).sum()
    eval_acc += num_correct.item()

print('Test Loss: {:.6f}, Acc: {:.6f}'.format(
    eval_loss / (len(test_dataset)),
    eval_acc / (len(test_dataset))
))
print('预测结果对照显示 (部分) ：')
pred_y = torch.max(out.cpu(), 1)[1].data.numpy().squeeze()

label = label.cpu().data.numpy().squeeze()
print(pred_y, '         prediction number')
print(label, '         real number')

模型测试

#keras 预测
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import torch
import os
import torch.utils.data as Data
import torch.nn as nn
from torch.autograd import Variable
import torch.nn.functional as F
import utils
"""
测试数字识别
"""

root_path = r'..\..\data\test_images'
im_h = 46
w = 30
# 数字列表
digit_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '']
# 两层卷积两层全连接层
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=5, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True)
        )

        self.layer2 = nn.Sequential(
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Dropout(0.25),
        )

        self.layer3 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=5),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True)
        )

        self.layer4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Dropout(0.5),
        )

        self.fc = nn.Sequential(
            nn.Linear(2880, 256),
            nn.ReLU(inplace=True),
            # nn.Dropout(0.5),
            nn.Linear(256, 84),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(84, 11),
        )

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

def to_digit(index):
    return digit_list[index]

def getPred(pred):
    res = ''
    for i in range(4):
        index = pred[i]
        if to_digit(index) == '':
            res += '_'
        else:
            res += digit_list[index]
    return res

model=torch.load("cnn1.pkl")

model.cuda()
import cv2
files = os.listdir(root_path)
for file in files:
    im_path = os.path.join(root_path, file)

    im = utils.load_img(im_path)
    im = utils.rgb2gray_2(im)

    # im = utils.rgb2gray_2(im)
    im = im.reshape(im.shape[0], 1,im_h, w)
    # print(im.shape)

    im = torch.from_numpy(im)  # numpy_data为numpy类型
    im = im.type(torch.FloatTensor)  # 转LongTensor
    im = Variable(im)
    if torch.cuda.is_available():
        im = im.cuda()

    out = model(im)
    _, pred = torch.max(out, 1)

    pred = pred.cpu().numpy()          #tensor_data为tensor张量
    pred = list(pred)
    pred = getPred(pred)
    print('label: ', file[:-4][0:4], '   digits: ', pred)

 

（三）keras写法：

utils.py

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import keras
import os

"""
图片处理与数据加载相关工具方法
"""

# 数字列表
digit_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '']

# 常量
im_h = 46       # 图片高度
im_w = 120      # 图片宽度
im_chan = 3     # 图片通道数目
im_chan_2 = 4   # 图片通道数目
im_n = 4        # 每张图片分割的子图数目
w = 30          # 分割图片宽度，为im_w的四分之一


def rgb2gray(rgb):
    """
    将rgb图转换为灰度图
    :param rgb:
    :return:
    """
    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
    return gray


def rgb2gray_2(arr):
    """
    将四张子图组成的rgb图片转换成对应的灰度图组合数组
    origin: (4, 46, 30, 3)
    target: (4, 46, 30)
    :param arr:
    :return:
    """
    res = np.zeros((im_n, im_h, w))
    for i in range(im_n):
        res[i] = rgb2gray(arr[i])
    return res


def splice_img(arr):
    """
    拼接图片
    origin: (4, 43, 30, 3)
    target: (43, 120, 3)
    :param arr: 四张子图片数组
    :return:
    """
    im = np.zeros((im_h, im_w, im_chan))
    for i in range(im_n):
        im[:, i*w:(i+1)*w, :] = arr[i]
    return im


def load_img(path):
    """
    加载某张图片，每张分割成四张图片，返回x数组
    origin: (43, 120, 3)
    target: (4, 43, 30, 3)
    :param path: 图片路径
    :return:
    """
    im = plt.imread(path)
    im.resize(im_h, im_w, im_chan)       # 压缩成标准尺寸
    x = np.zeros((im_n, im_h, w, im_chan))        # 分割成四张图片
    for i in range(im_n):
        x[i] = im[:, i*w:(i+1)*w, :]
    return x


# def load_img_2(path):
#     """
#     加载某张图片，每张分割成四张图片，返回x数组和y标签
#     origin: (43, 120, 3)
#     target: (4, 43, 30, 3)  (4,)
#     :param path:
#     :return:
#     """
#     im = plt.imread(path)
#     im.resize(im_h, im_w, im_chan)       # 压缩成标准尺寸
#     x = np.zeros((im_n, im_h, w, im_chan))        # 分割成四张图片
#     for i in range(im_n):
#         x[i] = im[:, i*w:(i+1)*w, :]
#     labels = []
#     for k in path[-11:-7]:
#         if k == '_':
#             labels.append(-1)
#         else:
#             labels.append(int(k))
#     y = np.array(labels)
#     return x, y


def load_dir_img(path):
    """
    加载目录下所有的灰度图片，每张分割成四张图片，返回x数组和y标签数组
    :param path:
    :return:
    """
    files = os.listdir(path)
    # x = np.zeros((len(files)*im_n, im_h, w, im_chan))
    x = np.zeros((len(files)*im_n, im_h, w))
    y = np.zeros(len(files)*im_n)
    for i in range(len(files)):
        file_path = os.path.join(path, files[i])
        im = plt.imread(file_path)
        labels = []
        for k in files[i][0:im_n]:
            if k == '_':
                labels.append(-1)
            else:
                labels.append(int(k))

        for j in range(im_n):
            x[i*im_n+j] = im[:, j*w:(j+1)*w]
            y[i*im_n+j] = labels[j]

    return x, y


# def load_data(train_path='../../data/train/', test_path='../../data/test/'):
#     """
#     加载训练集和测试集
#     :param train_path:
#     :param test_path:
#     :return:
#     """
#     return load_dir_img(train_path), load_dir_img(test_path)


def load_data_2(img_dir='../../data/images_gray/', npz_path='../../data/digits.npz'):
    """
    加载目录下所有图片，自动分成训练集和测试集
    :param npz_path:
    :param img_dir:
    :return:
    """
    x, y = load_dir_img(img_dir)
    print('load images finished')
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=42)
    np.savez(npz_path, x_train=x_train, y_train=y_train, x_test=x_test, y_test=y_test)
    print('data saved as ', npz_path)
    return (x_train, y_train), (x_test, y_test)


def load_data_3(path='../../data/digits.npz'):
    """
    加载已保存的数据
    :param path:
    :return:
    """
    if os.path.exists(path):
        print('load saved data')
        with np.load(path) as f:
            x_train, y_train = f['x_train'], f['y_train']
            x_test, y_test = f['x_test'], f['y_test']
        return (x_train, y_train), (x_test, y_test)
    else:
        print('initial load data')
        return load_data_2(npz_path=path)


def to_digit(cate):
    """
    y标签转化为对应的数字
    :param cate:
    :return:
    """
    return digit_list[np.argmax(cate)]


def img_2_digits_mlp(im_path, model_path='model.h5'):
    """
    使用mlp模型预测图片中的数字，返回一个对应的数字字符串
    :param model_path:
    :param im_path:
    :return:
    """
    im = load_img(im_path)
    im = rgb2gray_2(im)
    x = im.reshape(im.shape[0], -1)     # 拉平矩阵
    model = keras.models.load_model(model_path)       # 加载训练好的模型
    y = model.predict(x)        # 预测
    res = ''
    for i in range(y.shape[0]):
        res += to_digit(y[i])

    return res
#
#
# def img_2_digits_cnn(im_path, model_path='model_cnn.h5'):
#     """
#     使用cnn模型预测图片中的数字，返回一个对应的数字字符串
#     :param im_path:
#     :param model_path:
#     :return:
#     """
#     im = load_img(im_path)
#     im = rgb2gray_2(im)
#     x = im.reshape(im.shape[0], im_h, w, 1)
#     model = keras.models.load_model(model_path)       # 加载训练好的模型
#     y = model.predict(x)        # 预测
#     res = ''
#     for i in range(y.shape[0]):
#         res += to_digit(y[i])
#
#     return res


def img_2_digits(x, model):
    """
    使用训练好的模型，预测结果
    :param x:
    :param model:
    :return:
    """
    y = model.predict(x)
    res = ''
    for i in range(y.shape[0]):
        if to_digit(y[i])=='':
            res += '_'
        else:
            res += to_digit(y[i])

    return res


if __name__ == '__main__':
    x, y = load_img_2('../../data/test/728_a_0.png')
    print(x)
    print(y)

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
# import utils
import torch.utils.data as Data

import keras
from keras.models import Sequential,load_model
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
import utils

"""
数字识别cnn模型
"""

batch_size = 256
num_classes = 11
epochs = 20

# input image dimensions
img_rows, img_cols = 46, 30

(x_train, y_train), (x_test, y_test) = utils.load_data_3()
print(x_train)
print(y_train)
print('origin')
print('x_train.shape: ', x_train.shape, ' y_train.shape: ', y_train.shape)
print('x_test.shape: ', x_test.shape, 'y_test.shape: ', y_test.shape)

# channel last default
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')

print('reshape x')
print('x_train',x_train)
print('x_train.shape: ', x_train.shape)
print('x_test.shape: ', x_test.shape)

print('by_train: ', y_train.shape)
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

print('cate y')
print(y_train)
print('ay_train: ', y_train.shape)
print('y_test: ', y_test.shape)

# Test accuracy: 0.9983770855873811
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))

model.summary()

model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])

model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_split=0.1)

model.save('model_cnn.h5')
print('model saved')

model = load_model('model_cnn.h5')
score = model.evaluate(x_test, y_test, verbose=0)

print('Test loss:', score[0])
print('Test accuracy:', score[1])

 

模型测试代码：

#keras 预测
import os
import utils
import keras

"""
测试数字识别
"""

root_path = r'D:\银行卡识别系统\CardIdentify-master1\data\test_images'
im_h = 46
w = 30

model = keras.models.load_model('model_cnn.h5')
model.summary()

files = os.listdir(root_path)
for file in files:
    im_path = os.path.join(root_path, file)
    im = utils.load_img(im_path)
    im = utils.rgb2gray_2(im)
    x = im.reshape(im.shape[0], im_h, w, 1)
    # x = im.reshape(im.shape[0], -1)     # 拉平矩阵
    print('label: ', file[:-4], '   digits: ', utils.img_2_digits(x, model))

 测试结果：