全连接神经网络：分类与回归示例
分类
创建测试数据
import random
import torch
import torch.utils.data
def get_rectangle():
"""
随机得到矩形的宽和高,值域0-1之间的小数,
判断这是否是一个"胖"的矩形
:return:
"""
width = random.random()
height = random.random()
fat = int(width >= height)
return width, height, fat
width, height, fat=get_rectangle()
print(width, height, fat)定义数据集（torch.utils.data.Dataset）
定义数据集一般是创建一个class继承torch.utils.data.Dataset，在这个class里面要定义三个函数，分别是init、len、getitem。init一般用于数据集的初始化，预处理等操作；len函数要输出这个数据集有多少条数据，按理来说我们这个测试数据是动态生成的，理论上来说有无穷多条，但在这样还是要给pytorch一个明确的数量；getitem函数是要根据序号i来获取一条数据。
class Dataset(torch.utils.data.Dataset):
#正常应该在这里执行数据的加载,处理等工作
def __init__(self):
pass
#定义数据的条数
def __len__(self):
return 500
#根据序号i,获取一条数据
def __getitem__(self, i):
#获取一个矩形的数据
width, height, fat = get_rectangle()
#定义宽高为x,定义是否胖为y
x = torch.FloatTensor([width, height])
y = fat
return x, y
dataset = Dataset()
print(len(dataset), dataset[0])500 (tensor([0.0132, 0.6463]), 0)
这里我们查看了dataset的数量，并查看了第0条数据。
数据遍历工具loader
这个loader是一个数据的加载器，我们把数据集传给dataset，并每八条数据为一个批次，然后我们打乱数据集当中的顺序，先前我们定义了500条数据，并非是8的整数倍，drop_last不足时直接丢弃。
loader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=8,
shuffle=True,
drop_last=True)
print(len(loader), next(iter(loader)))62 [tensor([[0.4461, 0.1130],
[0.6130, 0.8681],
[0.5334, 0.5767],
[0.9663, 0.4436],
[0.6687, 0.5886],
[0.5669, 0.7870],
[0.9415, 0.3396],
[0.2015, 0.5745]]), tensor([1, 0, 0, 1, 1, 0, 1, 0])]
定义神经网络模型
定义的方法也是创建class继承torch.nn.module，一般在这个class下有两个函数分别是init和forward，分别是用于模型初始化和神经网络的计算过程，先来看初始化部分，这里调用了一个sequential这样一个类，用于把多层神经网络给组合在一起，也就是前后串连的关系，算完一层再算完下一层
#全连接神经网络
class Model(torch.nn.Module):
#模型初始化部分
def __init__(self):
super().__init__()
#定义神经网络结构
self.fc = torch.nn.Sequential(
torch.nn.Linear(in_features=2, out_features=32),
torch.nn.ReLU(),
torch.nn.Linear(in_features=32, out_features=32),
torch.nn.ReLU(),
torch.nn.Linear(in_features=32, out_features=2),
torch.nn.Softmax(dim=1),
)
#定义神经网络计算过程
def forward(self, x):
return self.fc(x)
model = Model()
print(model(torch.randn(8,2)).shape)输入层是两个维度输入，分别就是宽和高，输出是32维的向量，激活函数ReLU将所有的负数归零，中间层就是32x32密集的网络，从这层可以很好的抽取数据当中的特征，输出还是一个Linear，输入是32维的向量，输出是两维的向量，符合我们二分类的条件，最后一层假如了softmax，这层的功能是让两个神经元输出为1，因为我们是一个二分类问题，希望其相加的结果为1。
训练模型
在训练模型部分，首先来初始化一个优化器，代码中使用的是Adam，learning rate为1e-4。因为是分类这里使用的celoss，然后我们调用train函数，对全量的数据遍历100轮，从loader中取到一批批的数据，然后我们把x放到模型中去计算，将模型计算的结果与真实的y进行求误差，也就是调用的loss函数，如果模型计算的结果根y是完全相同的情况下，它的loss应当是0，但一般是不可能的。有了loss再算梯度，调整模型当中的参数，调整完后使梯度归零，所有的pytorch都会经过这里的三个步骤。
def train():
#优化器,根据梯度调整模型参数
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
#计算loss的函数
loss_fun = torch.nn.CrossEntropyLoss()
#让model进入train模式,开启dropout等功能
model.train()
#全量数据遍历100轮
for epoch in range(100):
#按批次遍历loader中的数据
for i, (x, y) in enumerate(loader):
#模型计算
out = model(x)
#根据计算结果和y的差,计算loss,在计算结果完全正确的情况下,loss为0
loss = loss_fun(out, y)
#根据loss计算模型的梯度
loss.backward()
#根据梯度调整模型的参数
optimizer.step()
#梯度归零,准备下一轮的计算
optimizer.zero_grad()
if epoch % 20 == 0:
#计算正确率
acc = (out.argmax(dim=1) == y).sum().item() / len(y)
print(epoch, loss.item(), acc)
#保存模型到磁盘
torch.save(model, 'model/3.model')
关于使用哪一个工具类来计算loss，一般来说回归采用MSEloss，分类使用CEloss。
测试
代码中添加了一个注解，意思是在这个函数中不需要计算模型的梯度，因为在这个函数中执行的是测试，而非执行训练，所以不需要更新参数，所以也就不需要计算模型的梯度。首先要将训练好的模型给它加载进来。让模型进入测试模式，这样可以关闭模型当中的一些dropout之类的功能。从loader中获取一批数据，然后计算模型的正确率。
#测试
#注释的表明不计算模型梯度,节省计算资源
@torch.no_grad()
def test():
#从磁盘加载模型
model = torch.load('model/3.model')
#模型进入测试模式,关闭dropout等功能
model.eval()
#获取一批数据
x, y = next(iter(loader))
#模型计算结果
out = model(x).argmax(dim=1)
print(out, y)
print(out == y)回归
创建测试数据
#生成矩形数据的函数
def get_rectangle():
import random
#随机得到矩形的宽和高,值域0-1之间的小数
width = random.random()
height = random.random()
#计算面积
s = width * height
return width, height, s定义数据集
在这里初始化不需要进行任何操作，数据的条数理论上有无穷多条，但在pytorch中还是要明确指出，每次生成一条数据，将类型转为tensor。
import torch
#定义数据集
class Dataset(torch.utils.data.Dataset):
#正常应该在这里执行数据的加载,处理等工作
def __init__(self):
pass
#定义数据的条数
def __len__(self):
return 500
#根据序号i,获取一条数据
def __getitem__(self, i):
#获取一个矩形的数据
width, height, s = get_rectangle()
#定义宽高为x,定义面积为y
x = torch.FloatTensor([width, height])
y = torch.FloatTensor([s])
return x, y
dataset = Dataset()
print(len(dataset), dataset[0])数据遍历工具loader
#数据集加载器,每8条数据为一个批次,打乱顺序,不足8条时丢弃尾数
loader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=8,
shuffle=True,
drop_last=True)
print(len(loader), next(iter(loader)))loader的定义与上面的分类相同。
定义神经网络模型
class Model(torch.nn.Module):
#模型初始化部分
def __init__(self):
super().__init__()
#定义神经网络结构
self.fc = torch.nn.Sequential(
torch.nn.Linear(in_features=2, out_features=32),
torch.nn.ReLU(),
torch.nn.Linear(in_features=32, out_features=32),
torch.nn.ReLU(),
torch.nn.Linear(in_features=32, out_features=1),
)
#定义神经网络计算过程
def forward(self, x):
return self.fc(x)
model = Model()
print(model(torch.randn(8, 2)).shape)与上一个任务不一样的是，最后一层网络它是一个全连接神经网络，并且输出值为一个神经元
训练模型
def train():
#优化器,根据梯度调整模型参数
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
#计算loss的函数
loss_fun = torch.nn.MSELoss()
#让model进入train模式,开启dropout等功能
model.train()
#全量数据遍历100轮
for epoch in range(100):
#按批次遍历loader中的数据
for i, (x, y) in enumerate(loader):
#模型计算
out = model(x)
#根据计算结果和y的差,计算loss,在计算结果完全正确的情况下,loss为0
loss = loss_fun(out, y)
#根据loss计算模型的梯度
loss.backward()
#根据梯度调整模型的参数
optimizer.step()
#梯度归零,准备下一轮的计算
optimizer.zero_grad()
if epoch % 20 == 0:
print(epoch, loss.item())
#保存模型到磁盘
torch.save(model, 'model/4.model')
测试
#测试
#注释的表明不计算模型梯度,节省计算资源
@torch.no_grad()
def test():
#从磁盘加载模型
model = torch.load('model/4.model')
#模型进入测试模式,关闭dropout等功能
model.eval()
#获取一批数据
x, y = next(iter(loader))
#模型计算结果
out = model(x)
print(torch.cat([out, y], dim=1))将刚刚训练好的模型从磁盘上加载进来，获取一批数据，让模型进行计算，并查看模型的一个计算结果是否与真实的y之间是否接近。