将Mnist数据集减少类别并用lenet训练
Mnist数据集：包含60,000个用于训练的示例和10,000个用于测试的示例。这些数字已经过尺寸标准化并位于图像中心，图像是固定大小(28x28像素)。类别为数字0~9，共10类。
我们将Mnist数据集减少至只剩0、1的两类。
并使用lenet进行训练。
首先需要处理数据集：
需要自己新建文件夹，文件夹内包括图片（两个类别分成两个文件夹，如下）和图片对应的标签（下图中的txt，需要自己生成）
标签中包含：图片路径+类别（如下）
然后数据集部分就准备好了
代码修改：
原代码参考：https://www.bilibili.com/video/BV1vU4y1A7QJ/?spm_id_from=333.337.search-card.all.click
首先在代码根目录中新建.py文件，用于读取图片路径，代码如下：
from PIL import Image
from torch.utils.data import Dataset
import os
import time
import torch
from torch import nn
from torch.optim import lr_scheduler
from torchvision import datasets, transforms
import os
# from net import MyLeNet5
class MyDataset(Dataset):
def __init__(self, txt_path, transform = None, target_transform = None):
fh = open(txt_path, 'r')
imgs = []
for line in fh:
line = line.rstrip()
words = line.split()
imgs.append((words[0], words[1]))
self.imgs = imgs
self.transform = transform
self.target_transform = target_transform
def __getitem__(self, index):
fn, label = self.imgs[index]
#img = Image.open(fn).convert('RGB')
img = Image.open(fn)
if self.transform is not None:
img = self.transform(img)
return img, label
def __len__(self):
return len(self.imgs)
pipline_train = transforms.Compose([
#随机旋转图片
transforms.RandomHorizontalFlip(),
#将图片尺寸resize到32x32
transforms.Resize((32,32)),
#将图片转化为Tensor格式
transforms.ToTensor(),
#正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)
transforms.Normalize((0.1307,),(0.3081,))
])
pipline_test = transforms.Compose([
#将图片尺寸resize到32x32
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))
])
train.py中引用，xjj就是我在根目录中新建py，xjj.py
train.py中将读取数据集部分改为：
train_data = MyDataset('./data/LEDNUM/train.txt', transform=data_transform)
test_data = MyDataset('./data/LEDNUM/test.txt', transform=data_transform)
#train_data 和test_data包含多有的训练与测试数据，调用DataLoader批量加载
trainloader = torch.utils.data.DataLoader(dataset=train_data, batch_size=8, shuffle=True)
testloader = torch.utils.data.DataLoader(dataset=test_data, batch_size=4, shuffle=False)train.py中修改定义训练函数：
def train(dataloader, model, loss_fn, optimizer):
loss, current, n = 0.0, 0.0, 0
#numerate()会返回两个值, 一个是索引, 一个是数据，numerate()需要两个参数: 第一个参数是可迭代的对象，第二个参数是起始位置, 数据类型为int
for batch, (X,y) in enumerate(dataloader):#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
#前向转播
# X, y = X.to(device), y.to(device)
X, y = X, y
output = model(X)
##########
y_ = y
label_y = []
for _ in y_:
item = int(_)
label_y.append(item)
# y = list(y)
y = torch.tensor(label_y)
#print(type(y))
###############
cur_loss = loss_fn(output, y)
_, pred = torch.max(output, axis=1)#通过torch.max输出每一行的最大概率
cur_acc = torch.sum(y == pred)/output.shape[0]#16个批次即16张照片，通过y与预测值pred相比较，判断预测是否准确，如果准确返回1，不准确返回0，最后所有的加起来判断一批次的精确度，最后通过for判断一轮的精确度，得动精确度权重
#反向传播
optimizer.zero_grad()#优化器梯度清理
cur_loss.backward()
optimizer.step()#梯度更新
loss += cur_loss.item()#把这一批次的损失值累加的一起
current += cur_acc.item()#把所有的精度累加的一起
n = n+1
print("train_loss" + str(loss/n))#每一轮平均损失
print("train_acc" + str(current/n))#每一轮平均精确度这步增加了更改数据集格式，将图片矩阵改为张量
train.py中修改定义验证函数：
def val(dataloader, model, loss_fn):
#model.eval()是保证BN(Batch Normalization分批归一化)用全部数据的均值和方差；
model.eval()#改为验证模式，eval() 函数用来执行一个字符串表达式，并返回表达式的值。model.eval() 作用等同于 self.train(False)简而言之，就是评估模式
loss, current, n = 0.0, 0.0, 0
with torch.no_grad():#在模型不参与更新的情况下进行验证
for batch, (X, y) in enumerate(dataloader):
##########
y_ = y
label_y = []
for _ in y_:
item = int(_)
label_y.append(item)
# y = list(y)
y = torch.tensor(label_y)
# print(type(y))
###############
# 前向转播
# X, y = X.to(device), y.to(device)
output = model(X)
cur_loss = loss_fn(output, y)
_, pred = torch.max(output, axis=1)
cur_acc = torch.sum(y == pred) / output.shape[0]
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
print("val_loss" + str(loss / n))
print("val_acc" + str(current / n))
return current/n#返回精确度，精确度越高模型越好
net.py中修改类别和类别数
然后就可以训练了，结果如下：
