【python】pytorch包（第二章）API使用与介绍

GoesM

已于 2023-05-27 18:14:43 修改

阅读量1k

点赞数 1

分类专栏： python 人工智能文章标签： python pytorch 机器学习

于 2023-05-23 21:52:09 首次发布

本文链接：https://blog.csdn.net/l961983207/article/details/130835459

版权

python 同时被 2 个专栏收录

19 篇文章 1 订阅

订阅专栏

人工智能

12 篇文章 0 订阅

订阅专栏

1> nn.Module （用于构建模型的底层逻辑）

介绍

nn.Module 是 torch.nn 中的一个类，是pytorch中自定义网络的基类

__init__需要调用super方法，继承父类属性和方法
forward方法必须实现，用来定义网络的向前计算的过程

例：y = w*x + b 的拟合模型

构建

from torch import nn
class Lr(nn.Module): #构建模型逻辑
	def __init__(self): #定义该层
		super(Lr,self).__init__() #继承父类的init参数
		self.linear = nn.Linear( aa , bb ) 
		#该层网络的输入数据的维度为aa,输出数据的维度为bb
	def forward(self,x): 
		#即 如何由输入的数据x得到输出的结果out
		out = self.linear(x)
		return out

使用

#实例化模型
model = Lr()
#传入数据，计算结果
pred_y = model(x)

2> 优化器类 optimizer

介绍

优化器是torch为我们封装的用来更新参数的方法

设定优化器

torch.optim.SGD(参数, lr=学习率)
SGD（stochastic gradient descent, 随机梯度下降）
”参数“指：模型中需要被更新的参数;
”参数“一般用model.parameters()函数来获取，会获取所有requires_grad=True的参数
”学习率“：默认为0.001
torch.optim.Adam(参数, lr=学习率)

使用优化器

1. 步骤：
step 1. 优化器实例化
step 2. 将所有参数的梯度的值，初始化为0
step 3. 反向传播，更新梯度的值
step 4. 参数值被更新
2. 代码样例：

import optim from torch
#step 1. 优化器实例化
optimizer = optim.SGD(model.parameters(),lr=1e-3)
#待更新参数为model.parameters()
#学习率learning rate = 1e-3
#step 2. 将所有参数的梯度的值，初始化为0
optimizer.zero_grad() #参数归零函数
#step 3. 反向传播，更新梯度的值
loss.backward()
#step 4. 更新参数值
optimizer.step()

优化器的算法介绍

梯度下降法

(1) BGD 梯度下降法 (batch gradient descent)

每次迭代都将所有样本送入，将全局样本的均值作为参考。
简称为：全局优化
缺点： 每次都要跑全部样本，速度慢

(2) SGD 随机梯度下降法(Stochastic gradient descent)

每次从所有样本中，随机抽取一个样本进行学习
优点： 解决了BGD算法速度慢的问题
缺点： 可能被某个单个异常数据点影响
Python的torch包中的API调用方法： torch.optim.SGD()

(3) MBGD 小批量梯度下降法(Mini-batch gradient descent)

介于(1)和(2)之间的算法，每次选取一组样本进行学习

梯度下降法的劣势：

过于依赖于合适的学习率。
学习率较小时，会导致收敛速度慢；
学习率较大时，会导致有可能跳过最优解，在最值点左右摆动幅度较大

AdaGrad

采取动态调整学习率的方法，解决梯度下降法的劣势
【个人理解：就是把 爬山算法 换成了 模拟退火算法 】

动量法和 RMSProp算法

采取动态调整梯度的移动指数，解决梯度下降法的劣势
【个人理解：也是把 爬山算法 换成了 模拟退火算法 】

Adam算法

相当于 AdaGrad法和 RMSProp法的结合
优势更快达到最优解
劣势有可能学习得更慢（因为最优解很难找到，而前面的算法不一定会找到最优解，而是误差较大的最优解）
Python的torch包中的API调用方法： torch.optim.Adam()

3> dataset 基类

目的

当数据量十分巨大时，不可能将全部数据一次性放入模型中学习，而是要先随机打乱顺序，随机进行分组将原数据分为多个batch

在torch中提供了数据集的基类 torch.utils.data.Dataset，可以借助这个积累更加方便地实现上述目的，完成数据的加载

数据集类

可以自定义数据集类型，从而更好地调用
！一定要先完成定义，再进行使用！

定义

from toch.utils.data import Dataset.DataLoader
import pands as pd
#导入数据的文件路径
data_path = r"E:\data\data2"
class MyDataset(Dataset):
	def __init__(self): #定义数据集内容
		context = open(data_path,"r")
		#转化为dataFrame类型
		self.df = pd.Dataframe(context,columns=["label","sms"]
	def __getitem__(self,index):#定义索引方法
		single_item = self.df.iloc[index,:]
		return single_item.values[0],single_item.values[1]
	def __len__(self): #定义长度获取方法
		return self.df.shape[0]

使用

my_dataset = MyDataset() #命名
len(my_dataset) #数据集中的样本数量
my_dataset[ i ] #索引：第i个样本的数据内容

数据加载器类

定义该类函数，对数据集类进行操作
torch 提供了 torch.utils.data.DataLoader从而支持用户可以 分批数据(Batching the data) ，打乱数据 , 使用多线程加载数据

使用

from torch.utils.data import DataLoader
dataset = MyDataset()
data_loader = DataLoader (
	dataset=dataset, #要被处理的数据集
	batch_size=10,  #希望以每批数据为batch_size大小 进行分批
	shuffle=True, # 是否打乱数据，True为打乱，False为不打乱
	num_workers=2, #多少个线程同时进行加载
	drop_last = True #可能最后一批数据的样本量<=batch_size，为了避免干扰，
	#True使得去除最后一组,False使得保留最后一组
)
batch = len(data_loader) #表示数据被分为了batch批
data_loader[i] #表示第i批数据

注：

新获得的data_loader的数据类型依然是我们之前自定义的MyDataset()类。
len(data_loader)表示的不是样本数量，而是数据的批次数量
data_loader[i]索引的也是第 i 批样本数据
即： data_loader 的数据类型的单次样本为

pytorch自带的数据集

`tochvision`数据集

提供了对图片数据处理相关的api和数据
eg. torchvision.datasets.MNIST为手写数字图片数据

`torchtext`数据集

提供了文本数据处理相关的API和数据
eg. torchtext.datasets.IMDB为电影评价（影评）的文本数据

`MNIST`数据集

from torchvision.datasets import MNIST
data = MNIST(
	root='/files/', #将数据集存储在路径/files/内
	train =True, #True表示获取的是训练集，否则获取的是训练集
	download=True,#如果没有下载过数据集，则需要下载标True，否则标False
	transform= None #数据格式转换函数为None，表示不转换格式
	#transform的参数需要自行定义，定义方式如下文
)
print(data) #查询数据集基本情况
print(data[0][0].show(),data[0][1]) #查看第一个数据的图片

4> `torchvision.transforms`数据处理方法

`ToTensor()(img)`图像转张量

from torchvision import  transforms
#ToTensor()可以将img对象转换为张量格式
img = mnist[0][0]
img_Tensor = transforms.ToTensor()(mnist[0][0])
print(img_Tensor)

`Normalize(mean,std)(img)`张量标准化处理

from torchvision import transforms
import numpy as np
import torchvision
data = np.random.randint(0,255,size=12) #随机生成图片
img = data.reshape(2,2,3) #构建2*2大小的RBG图（三通道）
img = transforms.ToTensor()(img) #转张量
print(img)
img.show()
norm_img = transforms.Normalize( (10,10,10),(1,1,1))(img)#规范化处理：均值为10，标准差为1，对img进行处理
# 要求：均值和标准差的形状 和 通道数相同
print(norm_img)

`Compose(transforms)`将多个transforms组合使用

直接使用compose则可以依次执行compose中包含的操作

transforms.compose([
	torchvision.transforms.ToTensor(), #转换为Tensor
	torchvision.transforms.Normalize(mean,std) #正则化
])

4> 模型的保存与加载

保存

torch.save(
    model.state_dict(),
    r'E:\AI_Model_save\model_net.pt'
)#保存模型 .pt格式，路径自定义即可
torch.save(
    optimizer.state_dict(),
    r'E:\AI_Model_save\model_optimiter.pt'
)#保存优化器 .pt格式，路径自定义即可

加载

model.load_state_dict(torch.load(
    r'E:\AI_Model_save\model_net.pt'
)) #加载模型 .pt格式，路径自定义即可
optimizer.load_state_dict(torch.load(
    r'E:\AI_Model_save\model_optimiter.pt'
))#加载优化器 .pt格式，路径自定义即可