IT评测·应用市场-qidao123.com技术社区

标题: 零基础使用实战项目学会Pytorch [打印本页]

---

作者: 兜兜零元    时间: 2024-11-17 15:39
标题: 零基础使用实战项目学会Pytorch
目录
pytorch简介
1.线性回归
2.数据范例
2.1数据范例检验
2.2Dimension=0/Rank=0
2.3 Dim=1/Rank=1
2.4 Dim=2/Rank=2
3.一些方法
4.Pytorch完成分类任务
4.1模子参数
4.2 前向传播
4.3练习以及验证
4.4 三行搞定！
4.5 精确率
5、Pytorch完成回归任务
5.1 One-hot编码
5.2 生存一些量
5.3 尺度化操纵
5.4 构建网络模子
5.5 简单方法构建网络模子
6、Pytorch实现卷积神经网络
6.1导入数据集
6.2 卷积网络模块构建
6.3前向传播
6.4精确率
6.5练习网络模子
7、图像辨认常用模块解读
7.1数据读取与图像预处置惩罚
7.2加载models中提供的模子，并直接用练习好的权重当作初始化参数
7.3设置哪些层必要练习 
7.4参数更新
7.5 练习模块
8、Dataloader文件标注
8.1任务1：读取txt文件中的路径和标签
8.2任务2：分别把标签和数据存放在list中
8.3任务3：数据路径得完备
8.4任务4：将上述三步写在一起
8.5任务5：数据预处置惩罚（transform）
8.6任务6：根据写好的class类实例化自己的dataloader 
8.7任务7：用前试试，整个数据和标签对应下，看看对不对
9、LSTM文本任务
9.1 文本任务数据预处置惩罚

---

pytorch简介

通常，PyTorch 的用途如下：

• 替代 NumPy 以使用 GPU 的强大功能。
  
• 提供最大灵活性和速度的深度学习研究平台。
  

PyTorch 是一个由以下组件组成的库

Component	描述
torch	类似 NumPy 的 Tensor 库，具有强大的 GPU 支持
torch.autograd	基于 Tape 的主动微分库，支持 Torch 中全部可微分的张量操纵
torch.jit	编译堆栈 (TorchScript)，用于从 PyTorch 代码创建可序列化和可优化的模子
torch.nn	与 autograd 深度集成的神经网络库，旨在实现最大的灵活性
torch.multiprocessing	Python 多处置惩罚，但具有跨历程的神奇 torch Tensors 内存共享功能。适用于数据加载和 Hogwild 练习
torch.ultis	DataLoader 和其他实用函数以方便使用

        总的来说，是支持 GPU 的张量库，如果您使用 NumPy，那么您就使用了 Tensors（又名 ndarray）。

        本文必要python语言的基础。对于pytorch，学习方法是，边用边学，Torch只是个框架，查的过程才是学习的过程。
1.线性回归

        求loss的最小值，得出y与WiX+bi最接近的Wi和bi，这里y是(-∞，+∞)的，这就称为Linear Regression（线性回归，拟合）。在Linear Regression添加激活函数，使得y是0，的，这就是Logistic Regression
2.数据范例

        之前Numpy一般是在CPU上运行，数据范例是ndarray，而在Pytorch上，数据范例是Tensor（张量），且一般是在GPU上运行的。

        对于string范例，pytorch没有提供，但是可以①使用one-hot方法，即将字母改为一个1维向量。
     对于输入的数据，一般是array范例，必要将其转换为Tensor范例，方法如下：x_in_trans=map(torch.tensor,(x_in))，其中map是一个映射函数，将x_in转换为x_in_trans，格式由array转换为tensor。

Data Tpye	dytpe	CPU Tensor	GPU Tensor
32bit floating point	torch.float32/torch.float	torch.FloatTensor	Torch.cuda.FloatTensor
64bit floating point	torch.float64/torch.double	torch.DoubleTensor	Torch.cuda.DoubleTensor
8bit integer(unsigned)	torch.uint8	torch.ByteTensor	Torch.cuda.ByteTensor
8bit integer(signed)	torch.int8	torch.CharTensor	torch.cuda.CharTensor
16bit integer(signed)	torch.int16/torch.short	torch.ShortTensor	Torch.cuda.ShortTensor
32bit integer(signed)	torch.int32/torch.int	torch.IntTensor	Torch.cuda.IntTensor
64bit integer(signed)	torch.int64/torch.long	torch.LongTensor	torch.cuda.LongTensor

2.1数据范例检验

        可以用a.type()表现数据范例，也可以用isinstance(a,torch.FloatTensor)举行检验，使用这个data=data.cuda()，可以将数据转换在cuda上
2.2Dimension=0/Rank=0

        Dim=0的数据（标量），用于loss值的计算。
2.3 Dim=1/Rank=1

        可以是1*n的向量，在torch统称为张量，常用于Bias偏置量，也用于Linear Input线性层的输出。

2.4 Dim=2/Rank=2

        注意，Dim指的是维度，如a是2行3列的矩阵，则它的维度dim=2是2维的，size是它的形状，是size([2，3])，表示它的形状是2行3列的，也就是shape。即a.shape输出torch.size([2，3])，size是列表。a.size(0)表示的是size的第一个数据，即为2。同样的a.shape[0]输出也是2。Dim=2的张量，常用于LinearInput batch
3.一些方法

        x.shape即可获取x的格式。torch.size返回一个元组（tuple），包含了 PyTorch 张量 x 的各个维度的尺寸信息。注意，x.shape也返回一个元组（tuple），包含了 PyTorch 张量 x 的各个维度的尺寸信息。
        torch.nn.functional内置了一些常用的损失函数和激活函数。如cross_entropy交织熵损失函数。import torch.nn.functional as F;然后loss_func=F.cross_entropy，即可指定loss_func是交织熵损失函数。
        x.mm(weights)+bias即实现wx+b操纵，mm指的是矩阵乘法。对于w，它最开始是随机初始化weights=torch.randn([a,b],dtype=torch.float,requires_grad=True)即可完成对weights的随机初始化为a行b列的矩阵，randn是随机初始化方法，dtype=torch.float指的是元素为float范例，requires_grad=True表示是否必要更新。
4.Pytorch完成分类任务

4.1模子参数

1. class Model_Name (nn.Module):
2.         def __init__(self):
3.                 super().__init__()
4.                 self.hidden1=nn.Linear(784a,128b)
5. self.hidden2=nn.Linear(128a,256b)       
6. self.out=nn.Linear(256a,10b)
7. self.dropout=nn.Dropout(0.5)

复制代码

        Model_Name 是要定义的类名，它必须继承nn.Module父类。def __init__(self)是构造函数，这是接下来构建模子时必备的一些属性、一些参数。self.hidden1=nn.Linear(a,b)是使用了Linear函数实现“全连接”（wx+b），其中a表示输入，b表示输出（即输入784，输出128），必要几层就构建几层，对于分类任务，末了输出也是全连接，就是self.out=nn.Linear(256a,10b)，即输出10个分类. self.dropout=nn.Dropout(0.5)表示Dropout，0.5表示按照50%杀死部分“神经元”。以上就是模子所需的参数、属性。
        在torch中，前向传播必要自行定义，反向传播是主动的。
4.2 前向传播

1. def forward(self,x):
2.                 x=F.relu(self.hidden1(x))
3.                 x=self.dropout(x)
4.                 x=F.relu(self.hidden2(x))
5. x=self.dropout(x)
6. x=self.out(x)
7. return x

复制代码

        输入是x，这个x是数据中的batch数据的特性，如x是64*784，表示 batch是64，特性是784个（64个样本，每个样本784个特性）。这个前向传播使用到了模子参数中的东西。
        以上过程貌似没有定义权重参数，但是实则是pytorch主动定义了。使用以下方法获取哥哥权重参数：

1. net = Model_Name()
2. for name,parameter in net.named_parameter():
3.         print(name,parameter,parameter.size())

复制代码

        使用net实例化，再使用net调用named_parameter()即可获取这些参数的名字及参数。
4.3练习以及验证

1. def fit(steps,model,loss_func,opt,train_dl,valid_dl):
2.         for step in range(steps):
3.                 model.train()
4.                 for xb,yb in train_dl:
5.                         loss.batch(model,loss_func,xb,yb,opt)
6.                
7.                 model.valid()
8.                 with torch.no_grad():
9.                         losses,nums=zip(
10. *[loss_batch(model,loss_func,xb,yb) for xb,yb in valid_dl]
11. )
12.                         Val_loss=np.sum(np.multiply(losses,nums))/np.sum(nums)
13.                         print(‘当前step：’+str(step),’验证集损失：’+str(val_loss))       

复制代码

        steps指的是迭代次数，model是模子，loss_func是损失函数，opt是优化器，train_dl,valid_dl是练习集和验证集。这里的steps相当于epoch，而下面的for循环指的是batch（如果一共有1000个数据，每次练习100个，则batch就是100（每次练习100个数据），而epoch就是10（次迭代））。背面的zip就是python的基础了，是打包解包的方法。
以下是优化器的定义：

1. def get_model():
2.        model= Model_Name()
3.        return model,optim.SGD(model.parameters(),lr=0.001)

复制代码

        其中model定义了模子，optim调用SGD优化器，表示的是梯度下降，model.parameters()表示的是接下来要更新什么参数（这里就是全更新），lr是学习率。除了SGD，还有Adam，更为常用。
以下是loss.batch的定义：

1. def loss_batch(model,loss_func,xb,yb,opt=None):
2.         loss=loss_func(model(xb),yb)
3.         if opt is not None:
4.                 loss.backward()
5.                 opt.step()
6.                 opt.zero_grad()
7.         return loss.item(),len(xb)

复制代码

        这个loss_batch函数的目标就是求出损失loss（model(xb)是预测值,yb是真实值），其次是更新权重参数w，b（如果有优化器，就使用backward()举行反向传播，step()就是参数更新）。本来第一次，第二次，第n次迭代毫无关系，但是torch会举行累计，以是使用opt.zero_grad()将梯度置为零。将这三步视为必备，必须这样写。
4.4 三行搞定！

1. train_dl,valid_dl=get_data(train_ds,valid_ds,bs)
2.         model,opt=get_model()
3.         fit(20,l,loss_func,opt,train_dl,valid_dl)

复制代码

        获取数据，得到模子和优化器，练习以及验证
4.5 精确率

1. correct=0
2. total=0
3. for xb,yb in valid_ld:
4.         outputs = model(xb)
5.         _,predicted=torch.max(outputs.data,1)
6.         total+=yb.size(0)
7.         correct+=(predicted==yb).sum().item()
8. print(‘Aurracy of network :%d,%%’%(100*correct/total))

复制代码

       精确率在验证集或者测试集上完成计算.
5、Pytorch完成回归任务

回归任务就是经过一系列神经网络，返回一个值
5.1 One-hot编码

使用pandas的get_dummies函数完成

5.2 生存一些量

①将标签值存下②去掉标签值的那一列存下③生存名字④将features转换为ndarray格式。
5.3 尺度化操纵

将本来不是以中心对称的数据点，拉返来，使其中心对称

5.4 构建网络模子

       将输入数据转换为tensor格式。requires_grad表示要举行梯度更新。并指定学习率（就是更新梯度幅度的大小，再乘上学习率，就是在已知更新方向的基础上，要走多少距离，这个距离要小一点），在定义losses损失列表。

        这是前向传播的部分，mm是矩阵乘法，hidden经过wx+b操纵，在举行relu非线性激活函数，在一层后得到预测结果，并计算损失，将损失值添加进losses损失列表中（转化为ndarray格式，是因为matplotlib支持ndarray而不支持tensor）

      （以上代码依然在前向传播的for循环中）反向传播直接使用backward()完成，更新参数时，使用w.grad.data拿到梯度值，并乘以学习率，负号是因为：看似是梯度下降，是下山问题，但是现实是沿着梯度反方向去更新，是想找什么参数，让损失最低。由于每次迭代无关，以是然后清零。更新参数这个写法比较贫苦，现实是可以直接调包的。
5.5 简单方法构建网络模子

        batch_size是方便计算损失的（原先的是每个数据都举行计算损失，但是现实上数据量及其巨大，以是每batch_size大小的数据再举行一次损失计算）。Sequential就是顺序举行，按顺序完成操纵（先全连接，再激活函数：sigmoid和relu都行，再全连接）。损失计算也是调包，使用MSELoss损失函数。然后就是优化器，之前是w拿到梯度乘上学习率再添负号，现在是直接使用Adam优化器，并指定优化参数和学习率。Adam头脑如下，使用惯性方向，举行平行四边形法则，得到最优方向。

        使用batch头脑举行。每次只练习一个batch的数据（要加上start和end索引，以方便取出）。
6、Pytorch实现卷积神经网络

6.1导入数据集

        导入MNIST数据集，train=True指定练习集，train=False指定验证集，使用transform包将数据更改为tensor范例.
6.2 卷积网络模块构建

        CNN是类名字,__init__()是构造函数，Conv2d表示的二维卷积，Conv3d就是三位卷积，一般用于视频；Conv2d里面的元素，一是in_channel是通道数，1就是灰度图，3就是RGB图像；out_channel输出特性图个数（也是卷积核的个数）；kernel_size是卷积核大小；stride是步长；padding是填充操纵，padding为2就是在图像四周添加两圈的0。然后就是Relu非线性映射。再然后就是MasPool2d最大池化（kernelSize=2是在2*2举行池化）。
        然后就是第二个卷积，（16是in_channel是上个卷积的输出，32是out_channel，5是卷积核大小，1是步长，2是填充）。再继续举行，终极要举行全连接。

6.3前向传播

        x是输入，是batch×C×H×W的张量。x.view类似于reshape操纵，将数据变为H为x.size(0)，W为主动计算的结果，-1表示主动计算。全连接之前先要举行reshape（即view）操纵。
6.4精确率

        pred背面的[1]表示：max会返回两个值，第一个是这个最大值，第二个是最大值对于的索引，pred拿到的就是索引。然后统计相等的总数。
6.5练习网络模子

       nn.CrossEntropyLoss()为常用的交织熵损失函数的写法，损失函数为交织熵损失函数，并定义优化器。

        使用enumerate罗列，可以得出一batch idx，他就是个计数（1，2，3…….），使用该计数，可以在背面的batch idx%100=0的情况下举行validation（即每过100次跑一次验证集）。net train就是练习；output得到预测值；loss计算损失；梯度清理；反向传播；参数更新；算精确率精确多少个；将多少个精确的生存。

精确率计算是在验证集if语句下的，用于计算精确率，并打印。
7、图像辨认常用模块解读

7.1数据读取与图像预处置惩罚

        data_transformer中制定了全部图像的预处置惩罚操纵，ImageFolder假设全部的文件按文件夹生存好，每个文件夹下面存储同一类图片，文件夹名字为分类名字。

       Data Augmetation数据增强：全部黑体
        练习集预处置惩罚：transformer.Compose指的是按顺序完成下列操纵：Resize将图像转换为指定长宽的大小（这个大小很重要，越大效果越好但是时间越慢）；RandomRoatation（a）指的是在-a到a之间的角度随机旋转（最大45）；CenterCrop(64)指的是从中心随机裁剪为长宽是64的图像；RandomHorizontaFlip(p=0.5)是随机垂直翻转， p=0.5是翻转概率；ColorJitter(brightness=0.2,contrast=0.1,saturation=0.3,hue=0.1)依次分别是亮度、对比度、饱和度、色相（这个方法用的很少）；RandomGrayscale(p=0.025)指的是概率转换为灰度图（用的更少）。ToTensor转举动tensor格式，Normalize尺度化（第一个是尺度差，第二个是均值，每个元素指的是RGB三通道，这个数据来源是大型数据集的结果）
        验证集预处置惩罚：不用数据增强。直接resize成想要的的大小，并转化为tensor，并且举行归一化（数据用的是练习集的均值方差数据）。

       x是字典的key，在datasets调用ImageFolder。这里的方法不重要，后续有更为通用的方法。
7.2加载models中提供的模子，并直接用练习好的权重当作初始化参数

       就是backbone特性提取器，常见的有resnet，alexnet，vgg等等。使用方法有两个，一是在别人论文源码中，将模子复制过来，二是torchvision收录了一些经典网络，可以直接调包。

       迁徙学习：使用被人的模子以及权重练习自己的数据集。那么别人的模子如resnet并没有练习过花朵的数据集，这些权重能直接用吗？答案是可以的，因为它本身就是提取特性的，权重描述了提取特性好坏的能力，而不是针对不同数据集有不同权重。我们要做的只是微调。如何微调？调什么参数？若你的数据集比较小，则大部分不用改，只改小部分（如只改输出层）这个方法称为“冻住”。若数据集不大不小，则“冻住”地区小一些（只改从输出层向上几层）。若数据集很大，则每一层都调整权重。最少最少输出层得调整。
       model_name指定为resnet，feature extract指定为ture，指的是不更新任何权重。

       判断练习设备，是CPU还是GPU。

       指定模子为resnet18，即用的是18层的resnet，速度较快，也可以50层的或者153层的，根据条件选择。观察它的网络布局，发现每次卷积完会有BatchNorm2d操纵，是因为开始预处置惩罚时已经经过了归一化操纵，但是在每次卷积之后，分布会发生变化，以是必要再次归一化，使网络学习更好。这个BN层在每次卷积之后都添加。在末了全连接之前，resnet18举行的是全局平均池化（指定步长为1），类似于reshape（学习卷积时在全连接之前将数据拉为长条），加入现在数据是14*14*512，就是将14*14的数据取平均为一个值，512分别操纵得到512个值。
        设置set_parameter_requires_grad函数用于判断是否更新权重参数，for循环是遍历全部的模子参数，查看是否更新。
        通过如下函数，将模子更改为自己的。

7.3设置哪些层必要练习 

        模子生存为pt文件（生存的是网络布局图，全部的w，b权重参数，以后可以直接用该pt文件）。然后将全部的模子参数生存在param_to_update，如果当params.requires_grad为True的时候，才将param放进param_to_update。这些参数要在opt优化器举行更新。
7.4参数更新

        使用Adam更新参数，并定义了衰减策略，用的是stepLR，stepsize是每10次实行衰减，gamma表示学习率变为原来的gamma倍。还定义了交织熵损失函数。
7.5 练习模块

        定义时间、最好的精确率、练习设备、四个list、学习率、最好的模子
8、Dataloader文件标注

       标注文件一般是txt文件、json文件、xaml文件等等。

原始数据，先举行随机打乱random shuffle，得到队列，每多少个构成一个batch。
8.1任务1：读取txt文件中的路径和标签

        定义一个字典数据data infos，key是图片名字，v是图片内容，然后打开文件，以readline每行去读，strip是去掉换行符等等、split是字符串切分，以空格切分，将其存放在samples列表变量中（格式是[xxx,lables]，xxx是名字，一个大list有许多小list）。然后遍历samples这个大list，再在data infos以xxx为key，以lables为v，构建字典。
8.2任务2：分别把标签和数据存放在list中

       必要把全部的keys转换为list，全部的values转化为list，这是dataloader未来会在这里提数据。
8.3任务3：数据路径得完备

       因为一会要用这个路径去读取数据，以是路径得加上前缀。任务不同，数据不同，方法不同，但是肯定要读到图像数据。

       把前面的train dir与img路径合并。
8.4任务4：将上述三步写在一起

       起首导入Dataset和Dataloader包。并且构造函数__init__和__getitem__函数必须存在。完成的是两个list，一个是存放全部图像数据路径的list，一个是存放全部标签的list。

        __init__完成的是两个list，一个是存放全部图像数据路径的list，一个是存放全部标签的list。__getitem__的两个参数都不要更改，idx是随机的索引，起首是得到图像数据和标签数据，判断要不要数据增强，并将标签数据转换为tensor格式。会实行batch次__getitem__函数，batch自己指定，这batch个数据会进入模子。
        load annotation函数是将字典转换成list。
8.5任务5：数据预处置惩罚（transform）

       同样在__getitem__函数中完成。在transform这里就完成了数据转换为tensor格式。代码和之前一模一样。

8.6任务6：根据写好的class类实例化自己的dataloader 

实例化两个，train dataset和val dataset。

使用Dataloader包完成构建dataloader，传入对应的参数即可。

8.7任务7：用前试试，整个数据和标签对应下，看看对不对

       使用iter.(train_loader).next()试试，是一个batch数据。suqeeze是压缩某个没用的维度，可有可无。permute是转换维度的，tensor是BGR格式，先转为RGB格式，再变为numpy格式，方便画图。
9、LSTM文本任务

文本数据标签文件。消息主题分类，包含练习集、验证集、测试集。

9.1 文本任务数据预处置惩罚

        Google以为英文文本得当分词，中文文本得当分字，我们以分字举行，这是第一步。第二部是ID替换，有一个大的预料表（包含5000个常用字），每个字对应一个ID序号，将每个字替换为序号，这样文本转换为一个数字组成的list。第三步是映射表，即就是Embedding，词嵌入，将这个list转换为一个词向量（这个向量是大型企业练习出的，如搜狗，腾讯）。综上所述，预料表将文本转换为ID，映射表将ID转换为向量。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/)

Powered by Discuz! X3.4