目录
1. 数据处理：常用的手写数字识别数据集：MNIST数据集。
1. 数据处理：常用的手写数字识别数据集：MNIST数据集。
为了节省训练时间，本节选取MNIST数据集的一个子集进行后续实验，数据集的划分为：
- 训练集：1,000条样本
- 验证集：200条样本
- 测试集：200条样本
MNIST数据集分为train_set、dev_set和test_set三个数据集，每个数据集含两个列表分别存放了图片数据以及标签数据。比如train_set包含：
- 图片数据：[1 000, 784]的二维列表，包含1 000张图片。每张图片用一个长度为784的向量表示，内容是 28×2828×28 尺寸的像素灰度值（黑白图片）。
- 标签数据：[1 000, 1]的列表，表示这些图片对应的分类标签，即0~9之间的数字。
数据预处理：图像分类网络对输入图片的格式、大小有一定的要求，数据输入模型前，需要对数据进行预处理操作，使图片满足网络训练以及预测的需要。本实验主要应用了如下方法：
- 调整图片大小：LeNet网络对输入图片大小的要求为 32×3232×32 ，而MNIST数据集中的原始图片大小却是 28×2828×28 ，这里为了符合网络的结构设计，将其调整为32×3232×32；
- 规范化： 通过规范化手段，把输入图像的分布改变成均值为0，标准差为1的标准正态分布，使得最优解的寻优过程明显会变得平缓，训练过程更容易收敛。
将原始的数据集封装为Dataset类，以便DataLoader调用。
train_set, dev_set, test_set = json.load(gzip.open('./mnist.json.gz'))
train_images, train_labels = train_set[0][:1000], train_set[1][:1000]
dev_images, dev_labels = dev_set[0][:200], dev_set[1][:200]
test_images, test_labels = test_set[0][:200], test_set[1][:200]
train_set, dev_set, test_set = [train_images, train_labels], [dev_images, dev_labels], [test_images, test_labels]
print('Length of train/dev/test set:{}/{}/{}'.format(len(train_set[0]), len(dev_set[0]), len(test_set[0])))
image, label = train_set[0][0], train_set[1][0]
image, label = np.array(image).astype('float32'), int(label)
# 原始图像数据为长度784的行向量，需要调整为[28,28]大小的图像
image = np.reshape(image, [28,28])
image = Image.fromarray(image.astype('uint8'), mode='L')
print("The number in the picture is {}".format(label))
plt.figure(figsize=(5, 5))
plt.imshow(image)
plt.savefig('conv-number5.pdf')
plt.show()
# 数据预处理
transforms = transforms.Compose([transforms.Resize(32),transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5])])
# 将原始数据数据集封装为Dataset，以便DataLoader调用
class MNIST_dataset(Dataset):
def __init__(self, dataset, transforms, mode='train'):
self.mode = mode
self.transforms =transforms
self.dataset = dataset
def __getitem__(self, idx):
# 获取图像和标签
image, label = self.dataset[0][idx], self.dataset[1][idx]
image, label = np.array(image).astype('float32'), int(label)
image = np.reshape(image, [28, 28])
image = Image.fromarray(image.astype('uint8'), mode='L')
image = self.transforms(image)
return image, label
def __len__(self):
return len(self.dataset[0])
# 固定随机种子
random.seed(0)
# 加载 mnist 数据集
train_dataset = MNIST_dataset(dataset=train_set, transforms=transforms, mode='train')
test_dataset = MNIST_dataset(dataset=test_set, transforms=transforms, mode='test')
dev_dataset = MNIST_dataset(dataset=dev_set, transforms=transforms, mode='dev')2. 模型构建LeNet-5
网络共有7层，包含3个卷积层、2个汇聚层以及2个全连接层的简单卷积神经网络接，受输入图像大小为32×32=1 02432×32=1024，输出对应10个类别的得分。
之前自定义的卷积和池化：
# 自定义卷积
class Conv2D(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0,
weight_attr=None, bias_attr=None):
super(Conv2D, self).__init__()
if weight_attr is None:
weight_attr = nn.init.constant_(torch.empty(out_channels, in_channels, kernel_size, kernel_size), 1.0)
if bias_attr is None:
bias_attr = nn.init.constant_(torch.empty(out_channels), 0.0)
# 创建卷积核
self.weight = nn.Parameter(weight_attr)
# 创建偏置
self.bias = nn.Parameter(bias_attr)
self.stride = stride
self.padding = padding
# 输入通道数
self.in_channels = in_channels
# 输出通道数
self.out_channels = out_channels
# 基础卷积运算
def single_forward(self, X, weight):
# 零填充
new_X = torch.zeros([X.shape[0], X.shape[1]+2*self.padding, X.shape[2]+2*self.padding])
new_X[:, self.padding:X.shape[1]+self.padding, self.padding:X.shape[2]+self.padding] = X
u, v = weight.shape
output_w = (new_X.shape[1] - u) // self.stride + 1
output_h = (new_X.shape[2] - v) // self.stride + 1
output = torch.zeros([X.shape[0], output_w, output_h])
for i in range(0, output.shape[1]):
for j in range(0, output.shape[2]):
output[:, i, j] = torch.sum(
new_X[:, self.stride*i:self.stride*i+u, self.stride*j:self.stride*j+v]*weight,
dim=[1,2])
return output
def forward(self, inputs):
"""
输入：
- inputs：输入矩阵，shape=[B, D, M, N]
- weights：P组二维卷积核，shape=[P, D, U, V]
- bias：P个偏置，shape=[P, 1]
"""
feature_maps = []
# 进行多次多输入通道卷积运算
p=0
for w, b in zip(self.weight, self.bias): # P个(w,b),每次计算一个特征图Zp
multi_outs = []
# 循环计算每个输入特征图对应的卷积结果
for i in range(self.in_channels):
single = self.single_forward(inputs[:,i,:,:], w[i])
multi_outs.append(single)
# print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
# 将所有卷积结果相加
feature_map = torch.sum(torch.stack(multi_outs), dim=0) + b #Zp
feature_maps.append(feature_map)
# print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
p+=1
# 将所有Zp进行堆叠
out = torch.stack(feature_maps, 1)
return out
# 自定义池化
class Pool2D(nn.Module):
def __init__(self, size=(2, 2), mode='max', stride=1):
super(Pool2D, self).__init__()
# 汇聚方式
self.mode = mode
self.h, self.w = size
self.stride = stride
def forward(self, x):
output_w = (x.shape[2] - self.w) // self.stride + 1
output_h = (x.shape[3] - self.h) // self.stride + 1
output = torch.zeros([x.shape[0], x.shape[1], output_w, output_h])
# 汇聚
for i in range(output.shape[2]):
for j in range(output.shape[3]):
# 最大汇聚
if self.mode == 'max':
output[:, :, i, j] = torch.max(
x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h])
# 平均汇聚
elif self.mode == 'avg':
output[:, :, i, j] = torch.mean(
x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
dim=[2, 3])
return output
模型构建：
# 调用自定义卷积池化函数实现模型构建
class Model_LeNet(nn.Module):
def __init__(self,in_channels,num_classes=10):
super(Model_LeNet, self).__init__()
self.conv1 = Conv2D(in_channels=in_channels, out_channels=6, kernel_size=5)
self.pool2 = Pool2D(size=(2,2),mode='max',stride=2)
self.conv3 = Conv2D(in_channels=6, out_channels=16, kernel_size=5)
self.pool4 = Pool2D(size=(2, 2), mode='avg', stride=2)
self.conv5 = Conv2D(in_channels=16, out_channels=120, kernel_size=5)
self.linear6 = nn.Linear(120, 84)
self.linear7 = nn.Linear(84, num_classes)
def forward(self, x):
output = F.relu(self.conv1(x))
output = self.pool2(output)
output = F.relu(self.conv3(output))
output = self.pool4(output)
output = F.relu(self.conv5(output))
output = torch.squeeze(output, dim=3)
output = torch.squeeze(output, dim=2)
output = F.relu(self.linear6(output))
output = self.linear7(output)
return output
# 调用torch内函数实现模型构建
class Torch_LeNet(nn.Module):
def __init__(self, in_channels, num_classes=10):
super(Torch_LeNet, self).__init__()
self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=6, kernel_size=5)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv3 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)
self.pool4 = nn.AvgPool2d(kernel_size=2, stride=2)
self.conv5 = nn.Conv2d(in_channels=16, out_channels=120, kernel_size=5)
self.linear6 = nn.Linear(in_features=120, out_features=84)
self.linear7 = nn.Linear(in_features=84, out_features=num_classes)
def forward(self, x):
output = F.relu(self.conv1(x))
output = self.pool2(output)
output = F.relu(self.conv3(output))
output = self.pool4(output)
output = F.relu(self.conv5(output))
output = torch.squeeze(output, dim=3)
output = torch.squeeze(output, dim=2)
output = F.relu(self.linear6(output))
output = self.linear7(output)
return output模型结构：
测试两个网络的运算速度。
import time
# 这里用np.random创建一个随机数组作为测试数据
inputs = np.random.randn(*[1,1,32,32])
inputs = inputs.astype('float32')
x = torch.tensor(inputs)
# 创建Model_LeNet类的实例，指定模型名称和分类的类别数目
model = Model_LeNet(in_channels=1, num_classes=10)
# 创建Paddle_LeNet类的实例，指定模型名称和分类的类别数目
torch_model = Torch_LeNet(in_channels=1, num_classes=10)
# 计算Model_LeNet类的运算速度
model_time = 0
for i in range(60):
strat_time = time.time()
out = model(x)
end_time = time.time()
# 预热10次运算，不计入最终速度统计
if i < 10:
continue
model_time += (end_time - strat_time)
avg_model_time = model_time / 50
print('Model_LeNet speed:', avg_model_time, 's')
# 计算torch_LeNet类的运算速度
torch_model_time = 0
for i in range(60):
strat_time = time.time()
torch_out = torch_model(x)
end_time = time.time()
# 预热10次运算，不计入最终速度统计
if i < 10:
continue
torch_model_time += (end_time - strat_time)
avg_torch_model_time = torch_model_time / 50
print('Paddle_LeNet speed:', avg_torch_model_time, 's')
根据结果来看：使用torch函数要比自定义的快很多。
这里还可以令两个网络加载同样的权重，测试一下两个网络的输出结果是否一致。计算参数量。
# 令两个网络加载同样的权重，测试一下两个网络的输出结果是否一致# 这里用np.random创建一个随机数组作为测试数据
inputs = np.random.randn(*[1,1,32,32])
inputs = inputs.astype('float32')
x = torch.tensor(inputs)
# 创建Model_LeNet类的实例，指定模型名称和分类的类别数目
model = Model_LeNet(in_channels=1, num_classes=10)
# 获取网络的权重
params = model.state_dict()
# 自定义Conv2D算子的bias参数形状为[out_channels, 1]
# paddle API中Conv2D算子的bias参数形状为[out_channels]
# 需要进行调整后才可以赋值
for key in params:
if 'bias' in key:
params[key] = params[key].squeeze()
# 创建Paddle_LeNet类的实例，指定模型名称和分类的类别数目
paddle_model = Torch_LeNet(in_channels=1, num_classes=10)
# 将Model_LeNet的权重参数赋予给Paddle_LeNet模型，保持两者一致
paddle_model.load_state_dict(params)
# 打印结果保留小数点后6位
torch.set_printoptions(6)
# 计算Model_LeNet的结果
output = model(x)
print('Model_LeNet output: ', output)
# 计算Paddle_LeNet的结果
paddle_output = paddle_model(x)
print('Torch_LeNet output: ', paddle_output)
# 统计一下LeNet-5模型的参数量和计算量。
model = Torch_LeNet(in_channels=1, num_classes=10)
params_info = torchsummary.summary(model, (1, 32, 32))
print(params_info)
from torchstat import stat
# 引入torch API计算
model = Torch_LeNet(in_channels=1, num_classes=10)
# 导入模型，输入一张输入图片的尺寸
stat(model, (1, 32, 32))
3. 模型训练，可视化观察训练集与验证集的损失变化情况。
import torch.optim as opt
from nndl.runner import RunnerV3
from nndl import metric
import torch.utils.data as io
torch.manual_seed(100)
# 学习率大小
lr = 0.2
# 批次大小
batch_size = 64
# 加载数据
train_loader = io.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
dev_loader = io.DataLoader(dev_dataset, batch_size=batch_size)
test_loader = io.DataLoader(test_dataset, batch_size=batch_size)
# 定义LeNet网络
# 自定义算子实现的LeNet-5
model = Torch_LeNet(in_channels=1, num_classes=10)
# API实现的LeNet-5
# model = Model_LeNet(in_channels=1, num_classes=10)
# 定义优化器
optimizer = opt.SGD(model.parameters(), lr=lr)
# 定义损失函数
loss_fn = F.cross_entropy
# 定义评价指标
metric = metric.Accuracy()
# 实例化 RunnerV3 类，并传入训练配置。
runner = RunnerV3(model, optimizer, loss_fn, metric)
# 启动训练
log_steps = 15
eval_steps = 15
runner.train(train_loader, dev_loader, num_epochs=6, log_steps=log_steps,
eval_steps=eval_steps, save_path="best_model.pdparams")
import matplotlib.pyplot as plt
# 可视化误差
def plot(runner, fig_name):
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
train_items = runner.train_step_losses[::30]
train_steps = [x[0] for x in train_items]
train_losses = [x[1] for x in train_items]
plt.plot(train_steps, train_losses, color='#8E004D', label="Train loss")
if runner.dev_losses[0][0] != -1:
dev_steps = [x[0] for x in runner.dev_losses]
dev_losses = [x[1] for x in runner.dev_losses]
plt.plot(dev_steps, dev_losses, color='#E20079', linestyle='--', label="Dev loss")
# 绘制坐标轴和图例
plt.ylabel("loss", fontsize='x-large')
plt.xlabel("step", fontsize='x-large')
plt.legend(loc='upper right', fontsize='x-large')
plt.subplot(1, 2, 2)
# 绘制评价准确率变化曲线
if runner.dev_losses[0][0] != -1:
plt.plot(dev_steps, runner.dev_scores,
color='#E20079', linestyle="--", label="Dev accuracy")
else:
plt.plot(list(range(len(runner.dev_scores))), runner.dev_scores,
color='#E20079', linestyle="--", label="Dev accuracy")
# 绘制坐标轴和图例
plt.ylabel("score", fontsize='x-large')
plt.xlabel("step", fontsize='x-large')
plt.legend(loc='lower right', fontsize='x-large')
plt.savefig(fig_name)
plt.show()
runner.load_model('best_model.pdparams')
plot(runner, 'cnn-loss1.pdf')
可视化：
4. 模型评价
# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))
5. 模型预测
# 获取测试集中第一条数据
X, label = next(iter(test_loader))
logits = runner.predict(X)
# 多分类，使用softmax计算预测概率
pred = F.softmax(logits,dim=1)
# 获取概率最大的类别
pred_class = torch.argmax(pred[2]).numpy()
label = label[2].numpy()
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))
# 可视化图片
plt.figure(figsize=(2, 2))
image, label = test_set[0][2], test_set[1][2]
image= np.array(image).astype('float32')
image = np.reshape(image, [28,28])
image = Image.fromarray(image.astype('uint8'), mode='L')
plt.imshow(image)
plt.savefig('cnn-number2.pdf')
plt.show()
总结：
在该实验中，主要是进行了基于LeNet实现手写体数字识别，体验了对于LeNet网络的流程，深入了解在实现过程中的细节。
实验中的主要流程：
上面训练模型是用的torch函数构建的Torch_LeNet模型，训练相对较快，而在相同条件下，自定义的Module_LeNet模型训练的很慢，计算量很大，而且会出现问题。如图：
所以在训练过程中，还是使用torch函数好使一些。
在这个实验中，首先遇到的问题就是数据集的加载，在这个过程中，学习了两个新库：
1. json:
全称为JavaScript Object Notation，也就是JavaScript对象标记，通过对象和数组的组合表示数据，虽然构造简洁但是结构化程度非常高，是一种轻量级的数据交换格式。
主要用于将python对象编码为json格式输出或存储，以及将json格式对象解码为python对象。这是它的主要用法：
2. gzip
此模块提供的简单接口帮助用户压缩和解压缩文件。
gzip.open(filename, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None)
以二进制方式或者文本方式打开一个gzip格式的压缩文件,返回一个file object。
filename 参数可以是一个实际的文件名（一个str对象或者bytes对象），或者是一个用来读写的已存在的文件对象。
mode参数可以是二进制模式： 'r', 'rb', 'a', 'ab', 'w', 'wb', 'x' or 'xb' , 或者是文本模式 'rt', 'at', 'wt', or 'xt'。默认值是 'rb'。
实验中使用了json和gzip两个包。json包用于处理JSON格式的数据，可以实现JSON数据的解析和序列化。gzip包则用于读取和写入gzip格式的文件，可以对文件进行压缩和解压缩操作。在这里，使用gzip.open打开gzip压缩的mnist.json.gz文件，并使用json.load加载数据集。
还有对于数据的预处理：图像分类网络对输入图片的格式、大小有一定的要求，数据输入模型前，需要对数据进行预处理操作，使图片满足网络训练以及预测的需要。主要应用了如下方法：
- 调整图片大小：LeNet网络对输入图片大小的要求为 32×3232×32 ，而MNIST数据集中的原始图片大小却是 28×2828×28 ，这里为了符合网络的结构设计，将其调整为32×3232×32；
- 规范化： 通过规范化手段，把输入图像的分布改变成均值为0，标准差为1的标准正态分布，使得最优解的寻优过程明显会变得平缓，训练过程更容易收敛。
实现：使用PyTorch中的transforms模块创建了一个数据预处理的管道。在这个管道中，包含了三个数据预处理的操作，它们按顺序依次执行。
- transforms.Resize(32): 这个操作将输入的图像调整为指定的大小，这里是将图像调整为32x32的大小。
- transforms.ToTensor(): 这个操作将图像数据转换为PyTorch张量的格式
- transforms.Normalize(mean=[0.5], std=[0.5]): 这个操作对图像进行标准化处理，将图像的像素值从[0, 1]范围缩放到均值为0，标准差为1的范围。这有助于提高模型训练的稳定性和收敛速度。
PyTorch中的transforms模块是用于对图像和数据进行预处理和转换的工具。它提供了一系列常用的数据处理操作，包括图像变换、数据标准化、数据增强等，可以方便地对数据进行各种处理，以满足神经网络训练的需求。
transforms模块中包含了许多常用的数据处理操作，比如：
- transforms.Resize(size, interpolation=2): 调整图像大小，可以将图像调整为指定的大小，也可以按照指定的比例进行缩放。
- transforms.CenterCrop(size): 对图像进行裁剪，可以将图像裁剪为指定的大小。
- transforms.RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant'): 对图像进行随机裁剪，可以在图像中随机选择一个区域进行裁剪。
- transforms.RandomHorizontalFlip(p=0.5): 对图像进行随机水平翻转，可以增加数据的多样性。
- transforms.ToTensor(): 将图像转换为张量格式，可以将图像数据转换为神经网络处理的标准格式。
- transforms.Normalize(mean, std, inplace=False): 对图像进行标准化，可以将图像的像素值进行归一化处理，使得图像数据更加稳定。
- transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0): 对图像进行色彩变换，可以随机调整图像的亮度、对比度、饱和度和色调。
- transforms.RandomAffine(degrees, translate=None, scale=None, shear=None, resample=False, fillcolor=0): 对图像进行仿射变换，可以对图像进行旋转、平移、缩放和错切等操作。
通过transforms模块，可以将这些数据处理操作组合在一起，形成一个数据预处理的管道，然后在数据加载时，直接使用这个管道对输入的图像进行预处理操作，从而简化了数据处理的流程。
查看模型信息：
torchsummary.summary函数是PyTorch中用于打印模型结构和参数信息的函数。它可以打印出模型的层结构、输入和输出形状、参数数量等信息，方便我们对模型进行调试和优化。
torchsummary.summary(model, input_size, device='cuda')model表示待打印结构信息的模型；input_size表示模型的输入形状，可以是一个元组或列表，如`(1, 3, 224, 224)`；device表示模型所在的设备，默认为`'cuda'`，即GPU。
torchsummary.summary`函数会自动计算模型的参数数量和内存占用情况，并打印出模型的结构信息。
其输出结果中，第一列是模型的层名称和类型；第二列是每一层的输出形状；第三列是每一层的参数数量；最后三行是模型的内存占用情况，包括输入大小、前向/后向传播大小和参数大小。
接下来就是训练过程：训练的流程和前面的基本一致，定义：随机种子、学习率大小、批次大小、加载数据、定义LeNet网络、定义优化器、定义损失函数、定义评价指标、实例化 Runner类，并传入训练配置，定义完成，启动训练。
扫一扫
2796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
