分类
创建测试数据
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)
与上一个任务不一样的是,最后一层网络它是一个全连接神经网络,并且输出值为一个神经元文章来源:https://www.toymoban.com/news/detail-591915.html
训练模型
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之间是否接近。文章来源地址https://www.toymoban.com/news/detail-591915.html
到了这里,关于全连接神经网络:分类与回归示例的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!