目录
前言
pytorch%EF%BC%89-toc" style="margin-left:40px;">（补充：四、安装GPU环境的pytorch）
正文
一、Pytorch
二、Tensor
三、CUDA
四、其他技巧
五、数据
六、torch.nn
前言
深度学习越来越火啦，深入到各行各业，小北个人也对深度学习很感兴趣，再加上这次导师暑期要求我们去配一下Pytorch深度学习环境，所以觉得有必要出一期教程~（小北以2022Y7000p拯救者+win11系统为栗子~）Anaconda安装及配置+pytorch深度学习环境(2024复旦计算机工作站0704）-CSDN博客https://blog.csdn.net/Zhiyilang/article/details/140177674?spm=1001.2014.3001.5502
https://blog.csdn.net/Zhiyilang/article/details/140177674?spm=1001.2014.3001.5502
友友们可以就着昨天小北的博客继续往下学习把~
pytorch%EF%BC%89">（补充：四、安装GPU环境的pytorch）
1.创建虚拟环境
首先打开Anaconda的命令行：
创建虚拟环境命令格式：
conda create -n 环境名 python=版本号conda create -n gpupytorch python=3.9友友们可以根据自己的需要去下载，输入命令后点击回车，然后输入y，回车：
下载完成！
2.进入虚拟环境
输入：
conda activate 环境名 
前面的括号里面的东西代表你现在处于哪个虚拟环境。
3.删除虚拟环境
如果你发现你的环境下错了，想删除这个环境，可以使用这句话：
conda remove -n 环境名 --allpytorch">4.安装GPU环境的pytorch
4.1. 确定自己显卡的算力
进入网站：CUDA GPU - 计算能力 |NVIDIA 开发者https://developer.nvidia.com/cuda-gpushttps://developer.nvidia.com/cuda-gpus
找到自己的显卡，例如：打开任务管理器(Shift+Ctrl+Esc)：
确定显卡为英伟达GeForce系列的笔记本系列RTX3050（Laptop）
然年后进入网站找到对应版本：
查询到算力为8.6，也可以去这个网站查询：CUDA - Wikipediahttps://en.wikipedia.org/wiki/CUDAhttps://en.wikipedia.org/wiki/CUDA
4.2. 确定CUDA runtime
在这张表中，找到友友你的算力可以匹配到哪个SDK，比如小北的是8.6，就适合11.8和12.0-12.3
这张表的出处：CUDA - Wikipediahttps://en.wikipedia.org/wiki/CUDAhttps://en.wikipedia.org/wiki/CUDA
打开网页后，直接按住Ctrl+F搜索GPUs supported就能看到。
4.3. 确定CUDA驱动版本
按住Win+r输入cmd打开命令行，输入
nvidia-smi
如果不显示此界面，请先更新显卡驱动，官网：官方驱动 | NVIDIAhttps://www.nvidia.cn/Download/index.aspx?lang=cnhttps://www.nvidia.cn/Download/index.aspx?lang=cn
选择符合自己电脑配置的版本，然后安装即可：
4.4. 进入Pytorch官网https://pytorch.org/
进入官网以后往下滑，找到命令：
下方的Compute Platform选取规则：
参考：23. GPU版本-GPU与CUDA准备工作_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1S5411X7FY?p=23&vd_source=5680f759e9cf6a3fca2a59373abcf3eahttps://www.bilibili.com/video/BV1S5411X7FY?p=23&vd_source=5680f759e9cf6a3fca2a59373abcf3ea或者根据小北下面说的也行
在4.3查询到的CUDA驱动版本为12.1，那么4.2查询到的适用版本就要小于等于12.1，即适用于11.8和12.0-12.1。
所以我选取CUDA11.8版本（我的选取12.1也可以），每个人要根据自己的电脑配置不同选取不同的命令。
直接复制命令：
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia4.5. 安装Pytorch
打开anaconda命令行窗口，进入到你的虚拟环境中，输入命令：
然后输入y，等待下载完成：
如果你觉得下载速度慢可以使用清华的镜像源安装（要么从清华的镜像源下载要么就从官网下载，二者选一个就好）：
清华镜像源：Index of /anaconda/cloud/pytorch/ | 清华大学开源软件镜像站 | Tsinghua Open Source Mirrorhttps://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
找到适合你的镜像，点进去：
然后复制网址：
把命令改成：
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c 刚才复制的链接然后输入命令等待下载完成。
4.6. 验证Pytorch
进入你的虚拟环境，输入
conda list
如果有Pytorch说明安装成功：
另一种方法：
在虚拟环境的命令行中输入
python然后输入
import torch等待导入完成，然后输入
torch.cuda.is_available()如果出现True，说明安装成功！
5.安装其他版本的Pytorch
如果你有安装其他版本Pytorch的需要，请继续往下看，如果没有，跳过即可。
进入官网，找到Get Started：
找到先前版本——选择你想下载的版本号，找到对应的命令下载即可：
正文
一、Pytorch
1.1 简介
Pytorch是torch的python版本，是由Facebook开源的神经网络框架，专门针对 GPU 加速的深度神经网络（DNN）编程。Torch 是一个经典的对多维矩阵数据进行操作的张量（tensor ）库，在机器学习和其他数学密集型应用有广泛应用。与Tensorflow的静态计算图不同，Pytorch的计算图是动态的，可以根据计算需要实时改变计算图。但由于Torch语言采用 Lua，导致在国内一直很小众，并逐渐被支持 Python 的 Tensorflow 抢走用户。作为经典机器学习库 Torch 的端口，PyTorch 为 Python 语言使用者提供了舒适的写代码选择。
至于为什么推荐使用Pytorch，我想最主要的原因就是它非常的简洁，非常符合Python的风格。
1.2 安装
首先确保你已经安装了GPU环境，即Anaconda、CUDA和CUDNN
随后进PyTorchhttps://pytorch.org/https://pytorch.org/
官网会自动显示符合你电脑配置的Pytorch版本，复制指令到conda环境中运行即可
测试是否安装成功 ：
python">import torch
print(torch.__version__) # pytorch版本
print(torch.version.cuda) # cuda版本
print(torch.cuda.is_available()) # 查看cuda是否可用
二、Tensor
Tensor张量是Pytorch里最基本的数据结构。直观上来讲，它是一个多维矩阵，支持GPU加速，其基本数据类型如下：
数据类型 CPU tensor GPU tensor
8位无符号整型 torch.ByteTensor torch.cuda.ByteTensor
8位有符号整型 torch.CharTensor torch.cuda.CharTensor
16位有符号整型 torch.ShortTensor torch.cuda.ShortTensor
32位有符号整型 torch.IntTensor torch.cuda.IntTensor
64位有符号整型 torch.LongTensor torch.cuda.LonfTensor
32位浮点型 torch.FloatTensor torch.cuda.FloatTensor
64位浮点型 torch.DoubleTensor torch.cuda.DoubleTensor
布尔类型 torch.BoolTensor torch.cuda.BoolTensor
2.1 Tensor创建
2.1.1 torch.tensor() && torch.tensor([])
二者的主要区别在于创建的对象的size和value不同
torch.randpern(n)为创建一个n个整数，随机排列的Tensor
2.1.3 torch.range(begin，end，step)
生成一个一维的Tensor，三个参数分别的起始位置，终止位置和步长
2.2 Tensor运算
函数 作用
torch.abs(A) 绝对值
torch.add(A，B) 相加，A和B既可以是Tensor也可以是标量
torch.clamp(A，max，min) 裁剪，A中的数据若小于min或大于max，则变成min或max，即保证范围在[min，max]
torch.div(A，B) 相除，A%B，A和B既可以是Tensor也可以是标量
torch.mul(A，B)点乘，A*B，A和B既可以是Tensor也可以是标量
torch.pow(A,n)
求幂，A的n次方
torch.mm(A,B.T) 矩阵叉乘，注意与torch.mul之间的区别
torch.mv(A,B) 矩阵与向量相乘，A是矩阵，B是向量，这里的B需不需要转置都是可以的
A.item() 将Tensor转化为基本数据类型，注意Tensor中只有一个元素的时候才可以使用，一般用于在Tensor中取出数值
A.numpy() 将Tensor转化为Numpy类型
A.size() 查看尺寸
A.shape查看尺寸
A.dtype 查看数据类型
A.view() 重构张量尺寸，类似于Numpy中的reshape
A.transpose(0，1) 行列交换
A[1:]A[-1，-1]=100
切面，类似Numpy中的切面
A.zero_() 归零化
torch.stack((A，B)，sim=-1) 拼接，升维
torch.diag(A) 取A对角线元素形成一个一维向量
torch.diag_embed(A) 将一维向量放到对角线中，其余数值为0的Tensor
2.2.1 A.add() && A.add_()
所有的带_符号的函数都会对原数据进行修改
2.2.2 torch.stack
stack为拼接函数，函数的第一个参数为需要拼接的Tensor，第二个参数为细分到哪个维度
python">A=torch.IntTensor([[1,2,3],[4,5,6]])
B=torch.IntTensor([[7,8,9],[10,11,12]])
C1=torch.stack((A,B),dim=0) # or C1=torch.stack((A,B))
C2=torch.stack((A,B),dim=1)
C3=torch.stack((A,B),dim=2)
C4=torch.stack((A,B),dim=-1)
print(C1,C2,C3,C4)
dim=0，C1 = [ A,B ]
dim=1，C2 = [ [ A[0],B[0] ] , [ A[1],B[1] ] ]
dim=2，C3 = [ [ [ A[0][0],B[0][0] ] , [ A[0][1],B[0][1] ] , [ A[0][2],B[0][2] ] ],
[ [ A[1][0],B[1][0] ] , [ A[1][1],B[1][1] ] , [ A[1][2],B[1][2] ] ] ]
dim=-1，C4 = C3
三、CUDA
CUDA是一种操作GPU的软件架构，Pytorch配合GPU环境这样模型的训练速度会非常的快
3.1 使用GPU
python">import torch
# 测试GPU环境是否可使用
print(torch.__version__) # pytorch版本
print(torch.version.cuda) # cuda版本
print(torch.cuda.is_available()) # 查看cuda是否可用
#使用GPU or CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 判断某个对象是在什么环境中运行的
a.device
# 将对象的环境设置为device环境
A = A.to(device)
# 将对象环境设置为COU
A.cpu().device
# 若一个没有环境的对象与另外一个有环境a对象进行交流,则环境全变成环境a
a+b.to(device)
# cuda环境下tensor不能直接转化为numpy类型,必须要先转化到cpu环境中
a.cpu().numpy()
# 创建CUDA型的tensor
torch.tensor([1,2],device)四、其他技巧
4.1 自动微分
神经网络依赖反向传播求梯度来更新网络的参数，求梯度是个非常复杂的过程，在Pytorch中，提供了两种求梯度的方式，一个是backward，将求得的结果保存在自变量的grad属性中，另外一种方式是torch.autograd.grad
4.1.1 backward求导
使用backward进行求导。这里主要介绍了求导的两种对象，标量Tensor和非标量Tensor的求导。两者的主要区别是非标量Tensor求导的主要区别是加了一个gradient的Tensor，其尺寸与自变量X的尺寸一致。在求完导后，需要与gradient进行点积，所以只是一般的求导的话，设置的参数全部为1。最后还有一种使用标量的求导方式解决非标量求导，了解了解就好了。
python">import numpy as np
import torch
# 标量Tensor求导
# 求 f(x) = a*x**2 + b*x + c 的导数
x = torch.tensor(-2.0, requires_grad=True)
a = torch.tensor(1.0)
b = torch.tensor(2.0)
c = torch.tensor(3.0)
y = a*torch.pow(x,2)+b*x+c
y.backward() # backward求得的梯度会存储在自变量x的grad属性中
dy_dx =x.grad
dy_dx
# 非标量Tensor求导
# 求 f(x) = a*x**2 + b*x + c 的导数
x = torch.tensor([[-2.0,-1.0],[0.0,1.0]], requires_grad=True)
a = torch.tensor(1.0)
b = torch.tensor(2.0)
c = torch.tensor(3.0)
gradient=torch.tensor([[1.0,1.0],[1.0,1.0]])
y = a*torch.pow(x,2)+b*x+c
y.backward(gradient=gradient)
dy_dx =x.grad
dy_dx
# 使用标量求导方式解决非标量求导
# 求 f(x) = a*x**2 + b*x + c 的导数
x = torch.tensor([[-2.0,-1.0],[0.0,1.0]], requires_grad=True)
a = torch.tensor(1.0)
b = torch.tensor(2.0)
c = torch.tensor(3.0)
gradient=torch.tensor([[1.0,1.0],[1.0,1.0]])
y = a*torch.pow(x,2)+b*x+c
z=torch.sum(y*gradient)
z.backward()
dy_dx=x.grad
dy_dx4.1.2 autograd.grad求导
python">
import torch
#单个自变量求导
# 求 f(x) = a*x**4 + b*x + c 的导数
x = torch.tensor(1.0, requires_grad=True)
a = torch.tensor(1.0)
b = torch.tensor(2.0)
c = torch.tensor(3.0)
y = a * torch.pow(x, 4) + b * x + c
#create_graph设置为True,允许创建更高阶级的导数
#求一阶导
dy_dx = torch.autograd.grad(y, x, create_graph=True)[0]
#求二阶导
dy2_dx2 = torch.autograd.grad(dy_dx, x, create_graph=True)[0]
#求三阶导
dy3_dx3 = torch.autograd.grad(dy2_dx2, x)[0]
print(dy_dx.data, dy2_dx2.data, dy3_dx3)
# 多个自变量求偏导
x1 = torch.tensor(1.0, requires_grad=True)
x2 = torch.tensor(2.0, requires_grad=True)
y1 = x1 * x2
y2 = x1 + x2
#只有一个因变量,正常求偏导
dy1_dx1, dy1_dx2 = torch.autograd.grad(outputs=y1, inputs=[x1, x2], retain_graph=True)
print(dy1_dx1, dy1_dx2)
# 若有多个因变量，则对于每个因变量,会将求偏导的结果加起来
dy1_dx, dy2_dx = torch.autograd.grad(outputs=[y1, y2], inputs=[x1, x2])
dy1_dx, dy2_dx
print(dy1_dx, dy2_dx)
4.1.3 求最小值
使用自动微分机制配套使用SGD随机梯度下降来求最小值
python">#例2-1-3 利用自动微分和优化器求最小值
import numpy as np
import torch
# f(x) = a*x**2 + b*x + c的最小值
x = torch.tensor(0.0, requires_grad=True) # x需要被求导
a = torch.tensor(1.0)
b = torch.tensor(-2.0)
c = torch.tensor(1.0)
optimizer = torch.optim.SGD(params=[x], lr=0.01) #SGD为随机梯度下降
print(optimizer)
def f(x):
result = a * torch.pow(x, 2) + b * x + c
return (result)
for i in range(500):
optimizer.zero_grad() #将模型的参数初始化为0
y = f(x)
y.backward() #反向传播计算梯度
optimizer.step() #更新所有的参数
print("y=", y.data, ";", "x=", x.data)
4.2 Pytorch层次结构
Pytorch中一共有5个不同的层次结构，分别为硬件层、内核层、低阶API、中阶API和高阶API（torchkeras）
硬件层 底层的计算资源包括CPU和GPU
内核层 使用C++来实现
低阶API Python实现的操作符，提供了封装C++内核的低级API指令，主要包括各种张量操作算 子、自动微分、变量管理. 如torch.tensor,torch.cat,torch.autograd.grad,nn.Module.
中阶API Python实现的模型组件，对低级API进行了函数封装，主要包括各种模型层，损失函数，优化器，数据管道等等。 如 torch.nn.Linear,torch.nn.BCE,torch.optim.Adam,torch.utils.data.DataLoader.
高阶API Python实现的模型接口。Pytorch没有官方的高阶API。为了便于训练模型，我们仿照 keras中的模型接口，使用了不到300行代码，封装了Pytorch的高阶模型接口
五、数据
Pytorch主要通过Dataset和DataLoader进行构建数据管道
5.1 Dataset and DataLoader
| Dataset | 一个数据集抽象类，所有自定义的Dataset都需要继承它，并且重写__getitem__()或__get_sample__()这个类方法 |
| DataLoader | 一个可迭代的数据装载器。在训练的时候，每一个for循环迭代，就从DataLoader中获取一个batch_sieze大小的数据。 |
5.2 数据读取与预处理
DataLoader的参数如下
python">DataLoader(
dataset,
batch_size=1,
shuffle=False,
sampler=None,
batch_sampler=None,
num_workers=0,
collate_fn=None,
pin_memory=False,
drop_last=False,
timeout=0,
worker_init_fn=None,
multiprocessing_context=None,
)在实践中，主要修改的参数以下标为橙色
dataset 数据集，决定数据从哪里读取，以及如何读取
batch_size 批次大小，默认为1
shuffle 每个epoch是否乱序
sampler 样本采样函数，一般无需设置
batch_sampler 批次采样函数，一般无需设置
num_workers 使用多进程读取数据，设置的进程数
collate_fn 整理一个批次数据的函数
pin_memory 是否设置为锁业内存。默认为False，锁业内存不会使用虚拟内存(硬盘)，从锁 业内存拷贝到GPU上速度会更快
drop_last 是否丢弃最后一个样本数量不足batch_size批次数据
timeout 加载一个数据批次的最长等待时间，一般无需设置
worker_init_fn 每个worker中dataset的初始化函数，常用于 IterableDataset。一般不使用
顺带介绍一下Epoch、Iteration、Batchsize之间的关系
| Epoch | 所有的样本数据都输入到模型中，称为一个epoch |
| Iteration | 一个Batch的样本输入到模型中，称为一个Iteration |
| Batchsize | 一个批次的大小，一个Epoch=Batchsize*Iteration |
先看数据读取的主要流程 
1. 从DataLoader开始
2. 进入DataLoaderIter，判断单线程还是多线程
3. 进入Sampler进行采样，获得一批一批的索引，这些索引告诉我们需要读取哪些数据、
4. 进入DatasetFetcher，依据索引读取数据
5. Dataset告诉我们数据的地址
6. 自定义的Dataset中会重写__getietm__方法，针对不同的数据来进行定制化的数据读取
7. 到这里就获取的数据的Text和Label
8. 进入collate_fn将之前获取的个体数据进行组合成batch
9. 一个一个batch组成Batch Data
再来看一个具体的代码
python">from torch.utils.data import DataLoader
from torch.utils.data.dataset import TensorDataset
# 自构建数据集
dataset = TensorDataset(torch.arange(1, 40))
dl = DataLoader(dataset,
batch_size=10,
shuffle=True,
num_workers=1,
drop_last=True)
# 数据输出
for batch in dl:
print(batch)
因为自定义的数据集只有39条，最后一个batch的数据量小于10，被舍弃掉了
而数据预处理主要是重写Dataset和DataLoader中的方法，因此总体代码如下所示
5.5 Pytorch工具
基于Pytorch已经产生了一些封装完备的工具，而缺点也很明显，数据处理不是很灵活，对于初学者来说，多写代码比较踏实，因此作者不太推荐使用这些方法
| torchvision | 图像视频处理 |
| torchaudio | 音频处理 |
| torchtext | 自然语言处理 |
六、torch.nn
torch.nn是神经网路工具箱，该工具箱建立于Autograd(主要有自动求导和梯度反向传播功能)，提供了网络搭建的模组，优化器等一系列功能。
搭建一个神经网络模型整个流程是怎么样的呢？
搭建网络流程
1 数据读取
2 定义模型
3 定义损失函数和优化器
4 模型训练
5 获取训练结果
我们拿一个最简单的FNN网络来对经典数据集diabetes糖尿病数据集来进行分类预测。
（博客开头）diabetes糖尿病数据集（本篇博客资源绑定）
python">
import numpy as np
import torch
import matplotlib.pyplot as plt
from torch.utils.data import Dataset, DataLoader
# Prepare the dataset
class DiabetesDateset(Dataset):
# 加载数据集
def __init__(self, filepath):
xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32, encoding='utf-8')
self.len = xy.shape[0] # shape[0]是矩阵的行数,shape[1]是矩阵的列数
self.x_data = torch.from_numpy(xy[:, :-1])
self.y_data = torch.from_numpy(xy[:, [-1]])
# 获取数据索引
def __getitem__(self, index):
return self.x_data[index], self.y_data[index]
# 获得数据总量
def __len__(self):
return self.len
dataset = DiabetesDateset('diabetes.csv')
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True, num_workers=2) # num_workers为多线程
# Define the model
class FNNModel(torch.nn.Module):
def __init__(self):
super(FNNModel, self).__init__()
self.linear1 = torch.nn.Linear(8, 6) # 输入数据的特征有8个,也就是有8个维度,随后将其降维到6维
self.linear2 = torch.nn.Linear(6, 4) # 6维降到4维
self.linear3 = torch.nn.Linear(4, 2) # 4维降到2维
self.linear4 = torch.nn.Linear(2, 1) # 2w维降到1维
self.sigmoid = torch.nn.Sigmoid() # 可以视其为网络的一层,而不是简单的函数使用
def forward(self, x):
x = self.sigmoid(self.linear1(x))
x = self.sigmoid(self.linear2(x))
x = self.sigmoid(self.linear3(x))
x = self.sigmoid(self.linear4(x))
return x
model = FNNModel()
# Define the criterion and optimizer
criterion = torch.nn.BCELoss(reduction='mean') # 返回损失的平均值
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
epoch_list = []
loss_list = []
# Training
if __name__ == '__main__':
for epoch in range(100):
# i是一个epoch中第几次迭代,一共756条数据,每个mini_batch为32,所以一个epoch需要迭代23次
# data获取的数据为(x,y)
loss_one_epoch = 0
for i, data in enumerate(train_loader, 0):
inputs, labels = data
y_pred = model(inputs)
loss = criterion(y_pred, labels)
loss_one_epoch += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss_list.append(loss_one_epoch / 23)
epoch_list.append(epoch)
print('Epoch[{}/{}],loss:{:.6f}'.format(epoch + 1, 100, loss_one_epoch / 23))
# Drawing
plt.plot(epoch_list, loss_list)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()
Result
注意点
1 创建模型的参数与__init__中的参数一致
2 训练模型的参数与forward中的参数一致
参考资料
本文章主要参考Github的各个大牛团队以及Pytorch的官方文档，感谢开源，开源万岁！
1 Chinese-Text-Classfication-Pytorch
2 Pytorch official Chinese documents
3 Pytorch official English doccuments
4 B站 PyTorch深度学习快速入门教程（小土堆）
5 pytorch-tutorial
6 Youtube--Pytorch
7 Pytorch--handbook
8 Deep Learning with PyTorch: A 60 Minute Blitz
————————————————
以下是作者两个较有诚意的工程，已开源。其中的代码框架结构是我看了较多论文源码后总结出来的一套较为清晰、规范的模板，且我的学术论文都是在此基础上修改的。工程的内容也是热门的CV和NLP领域两个基础性的任务，适合学完Pytorch后的工程实践
Bert/Roberta+Transformer_BILSTM_TextCNN实现IMDB文本分类
LeNet、AlexNet、GoogleLeNet、VGG16、ResNet实现COIL20图像分类
