简介
现在主流有两个框架pytorch和TensorFlow,本文主要介绍pytorch
- PyTorch:由 Facebook 的人工智能研究小组开发和维护。PyTorch 以其动态计算图(Dynamic Computational Graph)和易用性著称,非常适合研究人员和开发者进行实验和快速原型开发。
- TensorFlow:由 Google 开发和维护。TensorFlow 是一个更加成熟和全面的框架,支持大规模的生产环境部署,特别是在云计算和分布式计算方面具有优势。
然后介绍两个小工具:
dir() 打开该包,看看里面有什么东西;如果IDE使用的是pycharm的话,按住Ctrl 直接跳转,输入函数的参数的时候按住Ctrl+P可以看需要填哪些参数
**help()**官方解释文档,教你如何使用该工具
神经网络搭建步骤
数据集介绍
数据集为CIFAR10,
CIFAR-10 数据集由 10 个类的 60000 张 32x32 彩色图像组成,每个类有 6000 张图像。有 50000 张训练图像和 10000 张测试图像。图像大小为3x32x32
数据集分为 5 个训练批次和 1 个测试批次,每个批次有 10000 张图像。测试批次包含每个类中随机选择的 1000 张图像。训练批次包含按随机顺序排列的剩余图像,但某些训练批次可能包含来自一个类的图像多于另一个类的图像。在它们之间,训练批次正好包含来自每个类的 5000 张图像。
以下是数据集中的类,以及每个类的 10 张随机图像:
运行下列代码会导入数据集,没有下载的会自动下载
datasets导入数据集
dataloader分发数据,每批次送入64图片进入网络训练
transform更改图片数据的类型,比如将PIL改成tensor类型
python
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test = train_data.classes
print(test)
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)
搭建网络
由官网可知(官网链接:PyTorch documentation --- PyTorch 2.4 documentation),使用pytorch搭建网络至少需要重写2个函数,一个**init()** 初始化函数,另一个**forward()**前向传播函数,下图为官网截图:
按照官网给的例子我们重写,我们的网络结构如下图所示
网络结构如下图所示
代码思路:输入:3x32x32--->最后输出10个参数,具体过程如下图所示:
二维卷积参数计算公式如下图,根据输入输出计算padding和stride
代码实现
使用sequential()
python
class Wisdom(nn.Module):
def __init__(self):
super(Wisdom, self).__init__()
self.model1 = Sequential(
nn.Conv2d(3, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, padding=2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(1024, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model1(x)
return x
不使用sequential()
python
class Wisdom(nn.Module):
def __init__(self):
super(Wisdom, self).__init__()
self.conv1=Conv2d(3,32,5,padding=2)
self.maxpool1=MaxPool2d(2)
self.conv2=Conv2d(32,32,5,padding=2)
self.maxpool2=MaxPool2d(2)
self.conv3=Conv2d(32,64,5,padding=2)
self.maxpool3=MaxPool2d(2)
self.flatten=Flatten()
self.linear1=Linear(1024,64)
self.linear2= Linear(64, 10)
def forward(self,x):
x=self.conv1(x)
x=self.maxpool1(x)
x=self.conv2(x)
x=self.maxpool2(x)
x=self.conv3(x)
x=self.maxpool3(x)
x=self.flatten(x)
x=self.linear1(x)
x=self.linear2(x)
return x
实例化神经网络对象,损失函数,优化器
python
#创建神经网络
wisdom = Wisdom()
wisdom=wisdom.cuda()
#损失函数
loss_fn= nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)
损失函数(Loss Function)
常见的损失函数包括:
选择哪种损失函数取决于具体的任务和模型类型。在训练过程中,目标是最小化损失函数的值,从而提高模型的预测准确性。
优化器
优化器(Optimizer)是机器学习中用于调整模型参数以最小化损失函数的算法。优化器通过迭代过程逐步更新模型的权重和偏置,以找到损失函数的最小值。以下是一些常用的优化器:
设置网络参数
使用writer = SummaryWriter("logs_train")可以可视化整个训练过程
python
#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")
训练和验证网络并将重要信息可视化屏幕
重要代码解析:
**wisdom.train()**标志网络进入训练状态
**loss = loss_fn(outputs,targets)**计算损失函数
optimizer.zero_grad() 梯度置零,防止上个梯度对本轮训练产生影响
loss.backward() 反向传播
**optimizer.step()**梯度更新
**wisdom.eval()**模型进入测试状态
将损失值和精度闯入writer并绘制曲线图
writer.add_scalar("test_loss", total_test_loss, total_test_step) writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))保存训练好模型
python
for i in range(epoch):
print("----第{}轮开始----".format(i+1))
#开始训练
#进入训练状态
wisdom.train()
for data in train_dataloader:
imgs,targets = data
imgs=imgs.cuda()
targets=targets.cuda()
outputs = wisdom(imgs)
loss = loss_fn(outputs,targets)
#优化器调优
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step += 1
if total_train_step % 100 ==0:
print("训练次数:{},loss:{}:".format(total_train_step,loss))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#模型测试
#模型进入测试状态
wisdom.eval()
total_test_loss=0
total_accuracy = 0
with torch.no_grad():# 提高推理速度和节省内存
for data in test_dataloader:
imgs,targets = data
imgs = imgs.cuda()
targets = targets.cuda()
outputs = wisdom(imgs )
loss = loss_fn(outputs,targets)
total_test_loss=total_test_loss+loss.item()
accuracy = (outputs.argmax(1)==targets).sum()
total_accuracy=total_accuracy+accuracy
print("整体测试集合的loss:{}".format(total_test_loss))
print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step +=1
torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
print("模型已经保存!")
#torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()
使用GPU加速训练
确保电脑有显卡并正确安装驱动,而且要正确下载对应cuda
下载教程:
进入pytorch官网
根据自己的系统选择,一般使用anaconda 在Windows下进行python环境管理,复制红框部分,在Anaconda Prompt 粘贴运行,注意自己的cuda版本是否支持
查看cuda版本,打开英伟达控制面板,桌面右键或者系统右下角,然后点击系统信息,之后点击组件
GPU程序设置
在神经网络,损失函数的实例对象后加**.cuda()** 即可,以及在图片数据后加**.cuda()**
python
wisdom=wisdom.cuda()
loss_fn=loss_fn.cuda()
imgs=imgs.cuda()
targets=targets.cuda()
保存模型
python
torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
使用训练好的网络进行分类任务
加载网络模型
python
model = torch.load("./model_train/wisdom_49.pth")
若出现runtime error将模型加载方式换成下列语句,将GPU训练的模型映射到CPU
python
出现runtimer error 将模型加载方式换成下列语句,将GPU训练的模型映射到CPU
或者将分类的图片进行cuda加速
python
image = image.cuda()#使用GPU训练的模型需要加CUDA
使用SummaryWriter使训练可视化
打开Anaconda Prompt再激活环境后运行下列命令:
python
tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train
上列的地址根据train.py代码中的这个语句确定
python
writer = SummaryWriter("logs_train")
一定要改成自己的文件地址,具体操作见下图
可视化结果如下图所示
最后解释一个语句,**with torch.no_grad()**提高推理速度和节省内存
python
with torch.no_grad():# 提高推理速度和节省内存
for data in test_dataloader:
imgs,targets = data
imgs = imgs.cuda()
targets = targets.cuda()
outputs = wisdom(imgs )
loss = loss_fn(outputs,targets)
total_test_loss=total_test_loss+loss.item()
accuracy = (outputs.argmax(1)==targets).sum()
total_accuracy=total_accuracy+accuracy
程序汇总
train.py
使用cpu训练网络
python
import torchvision
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
#length长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练集长度:{}".format(train_data_size))
print("测试集长度:{}".format(test_data_size))
#使用dataloader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)
#创建神经网络
wisdom = Wisdom()
#损失函数
loss_fn= nn.CrossEntropyLoss()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)
#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")
#tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train"
for i in range(epoch):
print("----第{}轮开始----".format(i+1))
#开始训练
#进入训练状态
wisdom.train()
for data in train_dataloader:
imgs,targets = data
outputs = wisdom(imgs)
loss = loss_fn(outputs,targets)
#优化器调优
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step += 1
if total_train_step % 100 ==0:
print("训练次数:{},loss:{}:".format(total_train_step,loss))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#模型测试
#模型进入测试状态
wisdom.eval()
total_test_loss=0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs,targets = data
outputs = wisdom(imgs )
loss = loss_fn(outputs,targets)
total_test_loss=total_test_loss+loss.item()
accuracy = (outputs.argmax(1)==targets).sum()
total_accuracy=total_accuracy+accuracy
print("整体测试集合的loss:{}".format(total_test_loss))
print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step +=1
torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
print("模型已经保存!")
#torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()
train_gpu.py
使用GPU训练网络
python
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test = train_data.classes
print(test)
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
class Wisdom(nn.Module):
def __init__(self):
super(Wisdom, self).__init__()
self.model1 = Sequential(
nn.Conv2d(3, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, padding=2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(1024, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model1(x)
return x
#length长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练集长度:{}".format(train_data_size))
print("测试集长度:{}".format(test_data_size))
#使用dataloader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)
#创建神经网络
wisdom = Wisdom()
wisdom=wisdom.cuda()
#损失函数
loss_fn= nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()
#优化器
learn_rate =0.01
optimizer = torch.optim.SGD(wisdom.parameters(),lr=learn_rate)
#设置网络的一些参数
#记录的训练次数
total_train_step = 0
#记录测试次数
total_test_step = 0
#训练的轮数
epoch=10
#添加tensorboard
writer = SummaryWriter("logs_train")
#tensorboard --logdir "D:\pyc_workspace\learn_pytorch\logs_train"
for i in range(epoch):
print("----第{}轮开始----".format(i+1))
#开始训练
#进入训练状态
wisdom.train()
for data in train_dataloader:
imgs,targets = data
imgs=imgs.cuda()
targets=targets.cuda()
outputs = wisdom(imgs)
loss = loss_fn(outputs,targets)
#优化器调优
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step += 1
if total_train_step % 100 ==0:
print("训练次数:{},loss:{}:".format(total_train_step,loss))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#模型测试
#模型进入测试状态
wisdom.eval()
total_test_loss=0
total_accuracy = 0
with torch.no_grad():# 提高推理速度和节省内存
for data in test_dataloader:
imgs,targets = data
imgs = imgs.cuda()
targets = targets.cuda()
outputs = wisdom(imgs )
loss = loss_fn(outputs,targets)
total_test_loss=total_test_loss+loss.item()
accuracy = (outputs.argmax(1)==targets).sum()
total_accuracy=total_accuracy+accuracy
print("整体测试集合的loss:{}".format(total_test_loss))
print("整体测试集合的准确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step +=1
torch.save(wisdom,"./model_train/wisdom_{}.pth".format(i))
print("模型已经保存!")
#torch.save(wisdom.state_dict(),"./model_train/wisdom_{}.pth".format(i))
writer.close()
test.py
利用神经网络模型进行分类,记得把
img_path ="dog.jpg"改成自己的路径
python
import torch
import torchvision
from PIL import Image
from torch import nn
from torch.nn import Sequential
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
classes_list = train_data.classes#分类物体列表
img_path ="dog.jpg"
# img_path ="airplane.jpg"
image = Image.open(img_path)
#image = image.convert("RGB")#只保留为3通道
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32,)),torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)
class Wisdom(nn.Module):
def __init__(self):
super(Wisdom, self).__init__()
self.model1 = Sequential(
nn.Conv2d(3, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, padding=2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(1024, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model1(x)
return x
#加载网络模型
model = torch.load("./model_train/wisdom_49.pth")
#出现runtimer error 将模型加载方式换成下列语句,将GPU训练的模型映射到CPU
#model = torch.load("./model_train/wisdom_9.pth",map_location=torch.device("cpu"))
print(model)
image=torch.reshape(image,(1,3,32,32))#增加batch_size维度
model.eval()
with torch.no_grad():
image = image.cuda()#使用GPU训练的模型需要加CUDA
output = model(image)
print(output)
classes_index=output.argmax(1).item()
print(classes_list)
print("测试图片为:{}".format(classes_list[classes_index]))