最近刚开始接触机器学习，记录下目前的一些理解，以及看到的一些好文章mark一下
1.MINST数据集MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.
MINST手写字体识别，大概相当于机器学习领域的"Hello World"的存在
1.1数据集的下载即载入 1.2可以去官网下载MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges
# 设置训练数据集
data_train = torchvision.datasets.MNIST(
root='./data',
train=True,
transform=torchvision.transforms.ToTensor(),
download=True)
#将训练数据集载入DataLoader
train_loader = torch.utils.data.DataLoader(data_train, batch_size=100, shuffle=True)
torchvision.datasets是pytorch中集成的可以加载多个数据集的工具，包含图片分类，语义分割，视频等数据集，详情见
[Datasets — Torchvision 0.12 documentation (pytorch.org)](https://pytorch.org/vision/stable/datasets.html?highlight=utils data dataloader)进入该页面我们找到MINST就可以查看到使用MINST所需要的参数
也可以在pycharm中定位到这个代码，按Ctrl+P查看需要的参数，我们重点关注这几个
1.root指定数据集的路径，2.train设置该数据是否用来训练，3.download参数用来设置是否下载该数据集默认False
4.transform在pytorch封装了许多图像处理的方法，如填充(Pad)，Resize，CenterCrop(中心裁剪)，Grayscale(灰度图)，更多方法见：Illustration of transforms — Torchvision 0.12 documentation (pytorch.org)
而这里的ToTensor是常用的步骤，可以实现将PIL格式或者numpy.ndarray格式的输入转化为tensor数据类型
2.3data.DataLoaderDataLoader的意义就是做数据打包，参数含义重点关注这几个
首先的1. dataset用来指定传入的数据集，2. batch_size用来指定多少个数据为一组(如=64代表一次传入64张图片)，太大可能爆显存，3. shuffle用来设置是否随机采样(可以理解为图片顺序打乱？)，4. num_workers代表任务数量(理解为线程数)，5. drop_last设置是否丢弃最后的图片(当最后几张图片不满一个batch_size时丢弃)
3.MINST的内容的展示
(22条消息) MNIST数据集转为图片形式输出_zzZ_CMing的博客-CSDN博客_mnist图片 这篇博客有写怎么将MINST的数据保存到本地
显示几个数据
#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标
examples = enumerate(train_loader)
#next() 返回迭代器的下一个项目。
batch_idx, (example_data, example_targets) = next(examples)
# 绘制查看数据集内容
fig = plt.figure()
for i in range(16):
plt.subplot(4,4,i+1) #设置图像显示为2行3列
plt.tight_layout() #tight_layout会自动调整子图参数，使之填充整个图像区域。
plt.imshow(example_data[i][0], cmap='gray')
plt.title("Truth Number: {}".format(example_targets[i]))
plt.xticks([]) #不显示横纵坐标
plt.yticks([])
plt.show()
debug一下，发现图像的尺寸为[1000,1,28,28]，分别代表batch_size为1000，chanel(通道)数为1(灰度图)，图像尺寸为28x28
def train(net, epoch=1):
net.train()#设置training mode
run_loss = 0#损失
for num_epoch in range(epoch): #设置训练的轮数为epoch轮
print(f'epoch {num_epoch}')
for i, data in enumerate(train_loader):#i为索引，data为数据
# x, y = data[0], data[1] #也可以这么写
x,y = data #x,y分别代表数据和标注
outputs = net(x) #将数据放入神经网络中
loss = criterion(outputs, y) #计算损失
optimizer.zero_grad() #梯度清零
loss.backward() #反向传播
optimizer.step() #优化器更新参数
run_loss += loss.item()
if i % 100 == 99: #每训练100轮打印一次
print(f'[{(i + 1) * 100} / 60000] loss={run_loss / 100}')
run_loss = 0
test(net)
这段代码初学者肯定比较懵逼，比如说我，下面简单说几个
net.train()的作用如下可以看到，其实设不设置影响都不大，仅当你的模型中有使用Dropout()层或BatchNorm层时会有影响
由于pytorch的动态计算图，当我们使用loss.backward()和opimizer.step()进行梯度下降更新参数的时候，梯度并不会自动清零。并且这两个操作是独立操作。如果梯度不清零，pytorch中会将上次计算的梯度和本次计算的梯度累加。
有兴趣可以看这里(60 封私信 / 84 条消息) PyTorch中在反向传播前为什么要手动将梯度清零？ - 知乎 (zhihu.com)
损失函数损失函数使用主要是在模型的训练阶段，每个批次的训练数据送入模型后，通过前向传播输出预测值，然后损失函数会计算出预测值和真实值之间的差异值，也就是损失值。得到损失值之后，模型通过反向传播去更新各个参数，来降低真实值与预测值之间的损失，使得模型生成的预测值往真实值方向靠拢，从而达到学习的目的。我们接下来使用的是nn.CrossEntropyLoss()
优化器优化器或者优化算法，是通过训练优化参数，来最小化（最大化）损失函数。为了使模型输出逼近或达到最优值，我们需要用各种优化策略和算法，来更新和计算影响模型训练和模型输出的网络参数。接下来的我们使用的是Adam（自适应学习率优化算法）。关于各种优化器的对比详情见深度学习之——优化器 - 简书 (jianshu.com)
这几天看别人代码，感觉还是SGD（随机梯度下降）用的比较多
def test(net):
net.eval()#和上面的net.train()一样
test_loader = torch.utils.data.DataLoader(data_train, batch_size=10000, shuffle=False)
test_data = next(iter(test_loader))
with torch.no_grad():
# x, y = test_data[0], test_data[1]
x,y = data
outputs = net(x)
pred = torch.max(outputs, 1)[1]
print(f'test acc: {sum(pred == y) / outputs.shape[0]}')#计算出损失(每个之和除以数量)
什么是卷积神经网络（CNN），具体可以看这篇文章：一文看懂卷积神经网络-CNN（基本原理+独特价值+实际应用）- 产品经理的人工智能学习库 (easyai.tech)
人工神经网络（Artificial Neural Networks，ANN）是一种模拟生物神经系统的结构和行为，进行分布式并行信息处理的算法数学模型。ANN通过调整内部神经元与神经元之间的权重关系，从而达到处理信息的目的。而卷积神经网络（Convolutional Neural Network，CNN）是一种前馈神经网络，它由若干卷积层和池化层组成，尤其在图像处理方面CNN的表现十分出色。
一般的卷积神经网络结果如下
在pytorch中卷积被封装在nn.Conv2d()中，参数如下，后几个我没用过
关于卷积的输出尺寸怎么计算官网也有给出
光看这个直接给人看傻了，我们看点直观的例子，如下左图所示，下方灰色的3x3kernel是我们定义的卷积核，下方是我们输入的图像，四周白色的方框代表我们的填充(padding=1)，卷积核不断在输入图像上移动并计算，最终得到上方绿色的输出图像
再举个例子来求图像的输出尺寸，如下有一个28x28的输入，我们假设padding=2，步长为1，卷积核为5x5
则输出的图像尺寸就应该为（28 - 2 * 2 - 1 * (5-1)-1/1）+1 = 28,所有输出的尺寸也应该为28x28，即不变
3.1.2. 池化层池化层分最大池化层和平均池化层，对应代码中的MaxPool2d，和AvgPool2d，池化层能很好的压缩图片信息，而且保留一部分特征
最大池化层的作用过程如下，输入图像为5x5，我们用一个3x3的核对它做最大池化，每次都求出3x3中的最大值来得到结果，ceil_model为False是用来设定把不满足3x3的结果都丢弃掉(类似之前谈的drop_last)
平均池化也同理，只不过不是求出最大的而是求一个平均
激活函数的作用
神经网络中使用激活函数来加入非线性因素，提高模型的表达能力。
如果不用激励函数（其实相当于激励函数是f(x) = x），在这种情况下你每一层节点的输入都是上层输出的线性函数，很容易验证，无论你神经网络有多少层，输出都是输入的线性组合，与没有隐藏层效果相当，这种情况就是最原始的感知机（Perceptron）了，那么网络的逼近能力就相当有限。正因为上面的原因，需要引入非线性函数作为激励函数，这样深层神经网络表达能力就更加强大（不再是输入的线性组合，而是几乎可以逼近任意函数）。
常用的非线性激活函数有nn.ReLu()和nn.Sigmoid()他们的图像如下，可以看到ReLu在大于0时为x，小于0时为0
关于LeNet的几个版本介绍LeNet：第一个卷积神经网络 (ruanx.net)
LeNet 是几种神经网络的统称，它们是 Yann LeCun 等人在 1990 年代开发的。一般认为，它们是最早的卷积神经网络（Convolutional Neural Networks, CNNs）。模型接收灰度图像，并输出其中包含的手写数字。LeNet 包含了以下三个模型：
- LeNet-1：5 层模型，一个简单的 CNN。
- LeNet-4：6 层模型，是 LeNet-1 的改进版本。
- LeNet-5：7 层模型，最著名的版本。
这里我们使用LeNet5这个经典的神经网络，网络模型如下总共有7层
可以发现输入图像是32x32的，但MINST数据集的图像尺寸为28x28，可以得出padding=2，第一个卷积层输入chanel=1，输出chanel=6，第一个池化层从28x28到14x14，推断出kernel为2x2，按上图模型编写代码
class LeNet5(nn.Module):
def __init__(self):
super().__init__()
#这个注释的比较详细
self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2)
# self.pool1 = nn.AvgPool2d(2) #本来LeNet使用的平均池化不如最大池化
self.pool1 = nn.MaxPool2d(kernel_size=2)
self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(6, 16, 5)
# self.pool2 = nn.AvgPool2d(2)
self.pool2 = nn.MaxPool2d(2)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
#前向传播
def forward(self, x):
# x = torch.tanh(self.conv1(x)) #tanh在这里不如relu
x = torch.relu(self.conv1(x))
x = self.pool1(x)
# x = torch.tanh(self.conv2(x))
x = torch.relu(self.conv2(x))
x = self.pool2(x)
x = x.view(-1, 16 * 5 * 5) #改变矩阵维度
x = self.fc1(x)
x = self.fc2(x)
x = self.fc3(x)
return x
在LeNet上训练20轮后的acc最高可以达到99.86%可以说相当可以了，
在测试一下，在MINST数据集下的正确率确实很高了
但我自己手写了几个，发现正确率不怎么样，原因还不清楚是为什么，难道是我字太丑了？。。。还是说这个模型过拟合了？。。。
还有个坑说一下，一定要转灰度图单通道，不然会莫名其妙报很多错
是cpu版本的就用cpu训练，有gpu版本的就用gpu训练，要快很多，但是要注意，你用的什么设备训练出来的模型保存再加载的时候要指明设备。意思就是你不能用cpu训练了一个模型，然后你再加载的时候又用cuda来加速
import torch
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms
from torch.nn import ReLU
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from torch.optim import optimizer
from PIL import Image
# 用来记录最佳的acc
best_acc = 0
trans_to_tensor = transforms.Compose([
transforms.ToTensor()
])
data_train = torchvision.datasets.MNIST(
root='./data',
train=True,
transform=torchvision.transforms.ToTensor(),
download=True)
data_test = torchvision.datasets.MNIST(
'./data',
train=False,
transform=trans_to_tensor,
download=True)
train_loader = torch.utils.data.DataLoader(data_train, batch_size=100, shuffle=True)
x, y = next(iter(train_loader))
#MINST的通用训练方法
def test(net):
global best_acc
net.eval()
test_loader = torch.utils.data.DataLoader(data_train, batch_size=10000, shuffle=False)
test_data = next(iter(test_loader))
with torch.no_grad():
# x, y = test_data[0], test_data[1]
# x = x.cuda()
# y = y.cuda()
x, y = test_data
outputs = net(x)
pred = torch.max(outputs, 1)[1]
acc = sum(pred == y) / outputs.shape[0]
if acc > best_acc:
best_acc = acc
print(f'test acc: {acc}')
# net.train()
def train(net, epoch=1):
net.train()
run_loss = 0
for num_epoch in range(epoch):
print(f'epoch {num_epoch}')
for i, data in enumerate(train_loader):
# x, y = data[0], data[1]
x,y = data
# print(data)
outputs = net(x)
loss = criterion(outputs, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
run_loss += loss.item()
if i % 100 == 99:
print(f'[{(i + 1) * 100} / 60000] loss={run_loss / 100}')
run_loss = 0
test(net)
# LeNet5网络模型
class LeNet5(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2)
# self.pool1 = nn.AvgPool2d(2)
self.pool1 = nn.MaxPool2d(kernel_size=2)
self.conv2 = nn.Conv2d(6, 16, 5)
# self.pool2 = nn.AvgPool2d(2)
self.pool2 = nn.MaxPool2d(2)
self.fc1 = nn.Linear(in_features=16 * 5 * 5, out_features=120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# x = torch.tanh(self.conv1(x))
x = torch.relu(self.conv1(x))
x = self.pool1(x)
# x = torch.tanh(self.conv2(x))
x = torch.relu(self.conv2(x))
x = self.pool2(x)
x = x.view(-1, 16 * 5 * 5)
x = self.fc1(x)
x = self.fc2(x)
x = self.fc3(x)
return x
if __name__ == '__main__':
# res = []
# classes = ['0','1','2','3','4','5','6','7','8','9']
net_5 = LeNet5().cuda()
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.Adam(net_5.parameters())
train(net_5, epoch=20)
print(best_acc)
'''
@以下内容用来保存自己的模型并做验证
torch.save(net_5.state_dict(),'LeNet5_par.pt')#保存模型参数
torch.save(net_5,'LeNet5_all.pt')#保存整个模型
model = torch.load('./LeNet5_all_cpu.pt',map_location=torch.device("cpu"))
print(model)
for i in range(0,7):
image_path = f'./data/imgs/my_nums/{i}.jpg'
img = Image.open(image_path).convert('L')
transform = torchvision.transforms.Compose([torchvision.transforms.Resize([28,28]),
torchvision.transforms.ToTensor()])
image = transform(img)
image = torch.reshape(image, (-1, 1, 28, 28))
model.eval()
with torch.no_grad():
output = model(image)
prediction = torch.softmax(output, dim=1)
prediction = np.argmax(prediction)
plt.imshow(img)
plt.show()
res.append(prediction.item())
print(prediction.item())
print('----------')
print(res)
'''