免费wap自助建站系统,郴州市做网站,阳江问政平台投诉平台,微信营销成本文为小白入门Pytorch中的学习记录博客
小白入门pytorch 基础知识
导入torch#xff0c;查看torch版本
import torch
print(torch.__version__)输出结果#xff1a;
1.12.1cu113张量
在pytorch中#xff0c;张量#xff08;tensor#xff09;是最基本的数据结构。
…本文为小白入门Pytorch中的学习记录博客
小白入门pytorch 基础知识
导入torch查看torch版本
import torch
print(torch.__version__)输出结果
1.12.1cu113张量
在pytorch中张量tensor是最基本的数据结构。
零维张量—》标量维度为0一个单独的值,只有大小没有方向一维张量—》向量维度为1二维张量—》矩阵维度为2三维张量—》三维数组维度为3
零维张量
tensor torch.tensor(10)
print(tensor的形状, tensor.shape)
print(tensor的值, tensor)输出结果
tensor的形状 torch.Size([])
tensor的值 tensor(10)一维张量
tensor torch.tensor([1, 2, 3, 4, 5])
print(tensor的形状, tensor.shape)
print(tensor的值, tensor)输出结果
tensor的形状 torch.Size([5])
tensor的值 tensor([1, 2, 3, 4, 5])二维张量
tensor torch.tensor([[1, 2, 3], [4, 5, 6]])
print(tensor的形状, tensor.shape)
print( tensor)输出结果
tensor的形状 torch.Size([2, 3])
tensor([[1, 2, 3],[4, 5, 6]])torch.Size([2, 3])中的[2, 3]是代表2行3列
三维张量
tensor torch.tensor([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
print(tensor.shape)
print(tensor)输出结果
torch.Size([2, 2, 2])
tensor([[[1, 2],[3, 4]],[[5, 6],[7, 8]]])torch.Size([2, 2, 2]):包含两个二维矩阵每个二维矩阵的形状是2行2列
张量的操作
创建张量
列表创建
tensor torch.tensor([1, 2])
tensor输入结果
tensor([1, 2])元组创建
tensor torch.tensor((1, 2))
tensor输出结果
tensor([1, 2])通过Numpy创建
import numpy as np
data np.array([1, 2])
tensor torch.tensor(data)
tensor输出结果
tensor([1, 2], dtypetorch.int32)创建一个具有特定数据类型的张量
tensor torch.tensor([1, 2, 3], dtypetorch.float32)
print(tensor)
print(tensor.dtype)输出结果
tensor([1., 2., 3.])
torch.float32创建全零向量
zeros_tensor torch.zeros([2, 3]) # 创建一个2行3列的全零张量
print(zeros_tensor.shape)
zeros_tensor输出结果:
torch.Size([2, 3])
tensor([[0., 0., 0.],[0., 0., 0.]])torch.zeros()全零张量的函数
全1张量
ones_tensor torch.ones((2, 3)) # 创建一个2行3列的全1张量
print(ones_tensor.shape)
ones_tensor输出结果
torch.Size([2, 3])
tensor([[1., 1., 1.],[1., 1., 1.]])torch.ones()全1张量的函数
随机张量
rand_tensor torch.rand((2, 3)) # 创建一个2行3列随机张量, torch.rand()函数将生成一个0,1范围内均匀分布的随机张量
print(rand_tensor.shape)
print(rand_tensor)输出结果
torch.Size([2, 3])
tensor([[0.4723, 0.6665, 0.7575],[0.8820, 0.1854, 0.1162]])张量索引和切片
使用索引和切片操作来访问张量中的特定元素或子张量
tensor torch.tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
print(tensor)输出结果
tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])访问第一个元素
# 访问第一个元素
print(tensor[0, 0])切片操作
# 切片操作
tensor[:, 1] # 逗号两边的数字左边是控制行右边是控制列输出结果
tensor([2, 5, 8])# 取第一行和第三行的第一列和第三列的元素
tensor[::2, ::2]输出结果
tensor([[1, 3],[7, 9]])张量GPU加速
# 创建一个形状为(2, 2)的张量
tensor torch.tensor([[1, 2], [3, 4]])
tensor tensor.to(cuda) # 将张量转移到gpu上
tensor输出结果
tensor([[1, 2],[3, 4]], devicecuda:0)张量转移到CPU上
tensor tensor.to(cpu)
print(tensor)输出结果
tensor([[1, 2],[3, 4]])张量运算
可以对张量执行各种数学运算和操作如加法、减法、乘法、除法、矩阵乘法等
# 创建两个张量
tensor1 torch.tensor([1, 2, 3])
tensor2 torch.tensor([3, 3, 3])
# 加法
result tensor1 tensor2
print(加法的结果, result)
# 减法
result tensor1 - tensor2
print(减法的结果, result)
# 乘法
result tensor1 * tensor2
print(乘法的结果, result)
# 除法
result tensor1 / tensor2
print(除法的结果, result)加法的结果 tensor([4, 5, 6])
减法的结果 tensor([-2, -1, 0])
乘法的结果 tensor([3, 6, 9])
除法的结果 tensor([0.3333, 0.6667, 1.0000])张量与标量相加与标量相乘
# 张量与标量相加
tensor1 torch.tensor([1, 2, 3])
temp_var 1
result tensor1 temp_var
print(张量与标量相加结果, result)# 张量与标量相乘
tensor1 torch.tensor([1, 2, 3])
temp_var 2
result tensor1 * temp_var
print(张量与标量相乘结果, result)输出结果
张量与标量相加结果 tensor([2, 3, 4])
张量与标量相乘结果 tensor([2, 4, 6])张量的形状转换
tensor torch.tensor([[1, 2, 3], [4, 5, 6]]) # 2行3列
print(原来的张量\n,tensor)
tensor tensor.reshape(3, 2) # 3行2列
print(变换后的张量\n, tensor)输出结果
原来的张量tensor([[1, 2, 3],[4, 5, 6]])
变换后的张量tensor([[1, 2],[3, 4],[5, 6]])# 改变张量的形状与reshape功能相同
tensor torch.tensor([[1, 2, 3],[4, 5, 6]]) # 2行3列
print(原来的张量\n, tensor)
tensor tensor.view(3, 2) # 3行2列
print(变换后的向量\n, tensor)原来的张量tensor([[1, 2, 3],[4, 5, 6]])
变换后的向量tensor([[1, 2],[3, 4],[5, 6]])获取张量的数值
tensor torch.randn(1) # 如果张量中仅有一个元素可用item
print(tensor)
print(tensor.item())输出结果
tensor([-0.5515])
-0.5514923930168152张量转化为数组
tensor torch.tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
array tensor.numpy() # 将张量转化为Numpy数组
print(array)输出结果
[[1 2 3][4 5 6][7 8 9]]张量转化为列表
tensor torch.tensor([[1, 2, 3],[4, 5, 6]])
# 将张量转化为列表
tensor_list tensor.tolist()
tensor_list输出结果
[[1, 2, 3], [4, 5, 6]]自动求导原理
自动求导是一个关键的功能它允许我们自动计算梯度从而计算反向传播和优化
计算图
计算图是一个有向无环图它描述了计算过程中的操作和数据之间的依赖关系。在pytorch中每个计算图由一系列的节点和边组成。节点表示操作例如加法、乘法或者数据边表示数据的流动方向。计算图分为两个阶段前向传播 和 反向传播前向传播在前向传播阶段计算图从输入节点开始按照节点之间的依赖关系依次进行计算直到到达输出节点。在这个过程中每个节点将计算并传递输出给下一个依赖节点反向传播在反向传播阶段计算图从输出节点开始沿着边的反方向传播梯度。在这个过程中每个节点根据链式法则将梯度传递给输入节点以便计算它们的梯度通过构建计算图Pytorch可以记录整个计算过程并在需要时自动计算梯度。这使得我们可以轻松地进行方向传播并在优化算法中使用梯度信息。
梯度
梯度它表示了函数在某一点的变化率。在Pytorch中计算梯度是一项关键操作它允许我们通过反向传播算法有效地更新模型参数。梯度是一个向量其方向是指向函数值增长最快的方向而其大小表示函数值的变化率。在深度学习中我们通常希望最小化损失函数因此梯度的反方向更新模型参数以逐步降低损失值Pytorch中的torch.tensor类是Pytorch的核心数据结构同时也是计算梯度的关键。每个张量都有一个requires_grad,默认为False。如果我们希望计算某个张量的梯度需要将requires_grad设置为True那么就会开始追踪在该变量上的所有操作而完成计算后可以调用.backward()并自动计算所有的梯度得到的梯度都保存在属性.grad中。调用.detach()方法分离出计算的历史可以停止一个tensor变量继续追踪其历史信息同时也防止未来的计算会被追踪。如果希望防止追踪历史以及使用内存可以将代码放在with torch.no_grad():内这个做法在使用一个模型进行评估的时候非常有用因为模型包含一些带有requires_gradTrue的训练参数但实际上并不需要它们的梯度信息对于autograd的实现还有一个类也是非常重要的–FunctionTensor和Function两个类是有关联并建立了一个非循环的图可以编码成一个完整的计算记录每个Tensor变量都带有属性.grad_fn该属性引用了创建了这个变量的Function
梯度计算过程
在pytorch中计算梯度的过程中主要分为以下几个步骤
创建张量并设置requires_gradTrue首先要创建一个张量并将requires_grad属性设置为True, 以便pytorch跟踪其梯度
x torch.tensor([2.0, 3.0], requires_gradTrue)定义计算图接下来使用创建的张量进行计算可以使用任何pytorch支持的函数、操作和模型
y x**2 3*x 1计算梯度一旦我们得到了最终的输出张量我们可以使用backward()方法自动计算梯度
y.sum().backward()获取梯度值通过访问张量的grad属性我们可以获得计算得到的梯度值
print(x.grad)输出结果
tensor([7., 9.])梯度计算示例
线性回归
import torch # 创建训练数据
x_train torch.tensor([[1.0], [2.0], [3.0]])
y_train torch.tensor([[2.0], [4.0], [6.0]])#定义模型参数
w torch.tensor([[0.0]], requires_gradTrue)
b torch.tensor([[0.0]], requires_gradTrue)# 定义模型
def linear_regression(x):return torch.matmul(x, w) b# 定义损失函数
def loss_fn(y_pred, y):return torch.mean((y_pred - y)**2)# 优化器
optimizer torch.optim.SGD([w, b], lr0.01)# 训练模型for epoch in range(100):# 前向传播y_pred linear_regression(x_train)# 计算损失loss loss_fn(y_pred, y_train)print(loss)# 反向传播loss.backward()# 更新参数optimizer.step()# 清零梯度optimizer.zero_grad()
打印loss的结果看一下
tensor(18.6667, grad_fnMeanBackward0)
tensor(14.7710, grad_fnMeanBackward0)
tensor(11.6915, grad_fnMeanBackward0)
tensor(9.2573, grad_fnMeanBackward0)
tensor(7.3332, grad_fnMeanBackward0)
tensor(5.8121, grad_fnMeanBackward0)
tensor(4.6098, grad_fnMeanBackward0)
tensor(3.6593, grad_fnMeanBackward0)
tensor(2.9079, grad_fnMeanBackward0)
tensor(2.3139, grad_fnMeanBackward0)
tensor(1.8443, grad_fnMeanBackward0)
tensor(1.4730, grad_fnMeanBackward0)
tensor(1.1795, grad_fnMeanBackward0)
tensor(0.9474, grad_fnMeanBackward0)
tensor(0.7639, grad_fnMeanBackward0)
tensor(0.6187, grad_fnMeanBackward0)
tensor(0.5039, grad_fnMeanBackward0)
tensor(0.4131, grad_fnMeanBackward0)
tensor(0.3412, grad_fnMeanBackward0)
tensor(0.2844, grad_fnMeanBackward0)
tensor(0.2393, grad_fnMeanBackward0)
tensor(0.2037, grad_fnMeanBackward0)
tensor(0.1754, grad_fnMeanBackward0)
tensor(0.1530, grad_fnMeanBackward0)
tensor(0.1352, grad_fnMeanBackward0)
tensor(0.1211, grad_fnMeanBackward0)
tensor(0.1099, grad_fnMeanBackward0)
tensor(0.1009, grad_fnMeanBackward0)
tensor(0.0938, grad_fnMeanBackward0)
tensor(0.0881, grad_fnMeanBackward0)
tensor(0.0835, grad_fnMeanBackward0)
tensor(0.0798, grad_fnMeanBackward0)
tensor(0.0769, grad_fnMeanBackward0)
tensor(0.0744, grad_fnMeanBackward0)
tensor(0.0724, grad_fnMeanBackward0)
tensor(0.0708, grad_fnMeanBackward0)
tensor(0.0695, grad_fnMeanBackward0)
tensor(0.0683, grad_fnMeanBackward0)
tensor(0.0674, grad_fnMeanBackward0)
tensor(0.0665, grad_fnMeanBackward0)
tensor(0.0658, grad_fnMeanBackward0)
tensor(0.0652, grad_fnMeanBackward0)
tensor(0.0646, grad_fnMeanBackward0)
tensor(0.0641, grad_fnMeanBackward0)
tensor(0.0637, grad_fnMeanBackward0)
tensor(0.0632, grad_fnMeanBackward0)
tensor(0.0628, grad_fnMeanBackward0)
tensor(0.0625, grad_fnMeanBackward0)
tensor(0.0621, grad_fnMeanBackward0)
tensor(0.0618, grad_fnMeanBackward0)
tensor(0.0614, grad_fnMeanBackward0)
tensor(0.0611, grad_fnMeanBackward0)
tensor(0.0608, grad_fnMeanBackward0)
tensor(0.0605, grad_fnMeanBackward0)
tensor(0.0602, grad_fnMeanBackward0)
tensor(0.0599, grad_fnMeanBackward0)
tensor(0.0596, grad_fnMeanBackward0)
tensor(0.0593, grad_fnMeanBackward0)
tensor(0.0590, grad_fnMeanBackward0)
tensor(0.0587, grad_fnMeanBackward0)
tensor(0.0584, grad_fnMeanBackward0)
tensor(0.0581, grad_fnMeanBackward0)
tensor(0.0578, grad_fnMeanBackward0)
tensor(0.0576, grad_fnMeanBackward0)
tensor(0.0573, grad_fnMeanBackward0)
tensor(0.0570, grad_fnMeanBackward0)
tensor(0.0567, grad_fnMeanBackward0)
tensor(0.0565, grad_fnMeanBackward0)
tensor(0.0562, grad_fnMeanBackward0)
tensor(0.0559, grad_fnMeanBackward0)
tensor(0.0557, grad_fnMeanBackward0)
tensor(0.0554, grad_fnMeanBackward0)
tensor(0.0551, grad_fnMeanBackward0)
tensor(0.0549, grad_fnMeanBackward0)
tensor(0.0546, grad_fnMeanBackward0)
tensor(0.0543, grad_fnMeanBackward0)
tensor(0.0541, grad_fnMeanBackward0)
tensor(0.0538, grad_fnMeanBackward0)
tensor(0.0536, grad_fnMeanBackward0)
tensor(0.0533, grad_fnMeanBackward0)
tensor(0.0530, grad_fnMeanBackward0)
tensor(0.0528, grad_fnMeanBackward0)
tensor(0.0525, grad_fnMeanBackward0)
tensor(0.0523, grad_fnMeanBackward0)
tensor(0.0520, grad_fnMeanBackward0)
tensor(0.0518, grad_fnMeanBackward0)
tensor(0.0515, grad_fnMeanBackward0)
tensor(0.0513, grad_fnMeanBackward0)
tensor(0.0510, grad_fnMeanBackward0)
tensor(0.0508, grad_fnMeanBackward0)
tensor(0.0505, grad_fnMeanBackward0)
tensor(0.0503, grad_fnMeanBackward0)
tensor(0.0501, grad_fnMeanBackward0)
tensor(0.0498, grad_fnMeanBackward0)
tensor(0.0496, grad_fnMeanBackward0)
tensor(0.0493, grad_fnMeanBackward0)
tensor(0.0491, grad_fnMeanBackward0)
tensor(0.0489, grad_fnMeanBackward0)
tensor(0.0486, grad_fnMeanBackward0)
tensor(0.0484, grad_fnMeanBackward0)反向传播
反向传播原理
在深度学习中我们通常使用梯度下降法来最小化损失函数从而训练神经网络模型。而反向传播是计算损失函数对模型参数梯度的一种有效方法。通过计算参数梯度我们可以梯度的反方向更新参数使得模型的预测结果逐渐接近真实标签反向传播的几个步骤 前向传播将输入样本通过神经网络的前向计算过程计算出预测结果计算损失将预测结果与真实标签进行比较并计算损失函数的值反向传播梯度根据损失函数的值计算损失函数对模型参数的梯度参数更新根据参数的梯度和优化算法的规则更新模型的参数
反向传播示例
import torch
import torch.nn as nn
import torch.optim as optimclass LinearRegression(nn.Module):def __init__(self):super(LinearRegression, self).__init__()self.linear nn.Linear(1, 1) # 输入维度为1 输出维度为1def forward(self, x):return self.linear(x)
# 创建模型的实例、定义损失函数和优化器
model LinearRegression()
criterion nn.MSELoss() # 均方误差损失函数
optimizer optim.SGD(model.parameters(), lr0.01)
# 生成样本数据并进行训练
x_train torch.tensor([[1.0],[2.0],[3.0],[4.0]])
y_train torch.tensor([[2.0],[4.0],[6.0],[8.0]])# 训练模型
for epoch in range(100):# 梯度清零optimizer.zero_grad() # 前向传播y_pred model(x_train)# 计算损失loss criterion(y_pred, y_train)# 反向传播loss.backward()# 参数更新optimizer.step()print(loss)输出损失值
tensor(30.6108, grad_fnMseLossBackward0)
tensor(21.2626, grad_fnMseLossBackward0)
tensor(14.7759, grad_fnMseLossBackward0)
tensor(10.2748, grad_fnMseLossBackward0)
tensor(7.1515, grad_fnMseLossBackward0)
tensor(4.9841, grad_fnMseLossBackward0)
tensor(3.4801, grad_fnMseLossBackward0)
tensor(2.4364, grad_fnMseLossBackward0)
tensor(1.7120, grad_fnMseLossBackward0)
tensor(1.2093, grad_fnMseLossBackward0)
tensor(0.8603, grad_fnMseLossBackward0)
tensor(0.6181, grad_fnMseLossBackward0)
tensor(0.4498, grad_fnMseLossBackward0)
tensor(0.3330, grad_fnMseLossBackward0)
tensor(0.2518, grad_fnMseLossBackward0)
tensor(0.1953, grad_fnMseLossBackward0)
tensor(0.1560, grad_fnMseLossBackward0)
tensor(0.1286, grad_fnMseLossBackward0)
tensor(0.1095, grad_fnMseLossBackward0)
tensor(0.0961, grad_fnMseLossBackward0)
tensor(0.0866, grad_fnMseLossBackward0)
tensor(0.0800, grad_fnMseLossBackward0)
tensor(0.0753, grad_fnMseLossBackward0)
tensor(0.0718, grad_fnMseLossBackward0)
tensor(0.0694, grad_fnMseLossBackward0)
tensor(0.0675, grad_fnMseLossBackward0)
tensor(0.0661, grad_fnMseLossBackward0)
tensor(0.0651, grad_fnMseLossBackward0)
tensor(0.0642, grad_fnMseLossBackward0)
tensor(0.0635, grad_fnMseLossBackward0)
tensor(0.0629, grad_fnMseLossBackward0)
tensor(0.0623, grad_fnMseLossBackward0)
tensor(0.0619, grad_fnMseLossBackward0)
tensor(0.0614, grad_fnMseLossBackward0)
tensor(0.0610, grad_fnMseLossBackward0)
tensor(0.0606, grad_fnMseLossBackward0)
tensor(0.0602, grad_fnMseLossBackward0)
tensor(0.0598, grad_fnMseLossBackward0)
tensor(0.0595, grad_fnMseLossBackward0)
tensor(0.0591, grad_fnMseLossBackward0)
tensor(0.0587, grad_fnMseLossBackward0)
tensor(0.0584, grad_fnMseLossBackward0)
tensor(0.0580, grad_fnMseLossBackward0)
tensor(0.0577, grad_fnMseLossBackward0)
tensor(0.0573, grad_fnMseLossBackward0)
tensor(0.0570, grad_fnMseLossBackward0)
tensor(0.0566, grad_fnMseLossBackward0)
tensor(0.0563, grad_fnMseLossBackward0)
tensor(0.0560, grad_fnMseLossBackward0)
tensor(0.0556, grad_fnMseLossBackward0)
tensor(0.0553, grad_fnMseLossBackward0)
tensor(0.0550, grad_fnMseLossBackward0)
tensor(0.0546, grad_fnMseLossBackward0)
tensor(0.0543, grad_fnMseLossBackward0)
tensor(0.0540, grad_fnMseLossBackward0)
tensor(0.0537, grad_fnMseLossBackward0)
tensor(0.0533, grad_fnMseLossBackward0)
tensor(0.0530, grad_fnMseLossBackward0)
tensor(0.0527, grad_fnMseLossBackward0)
tensor(0.0524, grad_fnMseLossBackward0)
tensor(0.0521, grad_fnMseLossBackward0)
tensor(0.0518, grad_fnMseLossBackward0)
tensor(0.0515, grad_fnMseLossBackward0)
tensor(0.0512, grad_fnMseLossBackward0)
tensor(0.0508, grad_fnMseLossBackward0)
tensor(0.0505, grad_fnMseLossBackward0)
tensor(0.0502, grad_fnMseLossBackward0)
tensor(0.0499, grad_fnMseLossBackward0)
tensor(0.0496, grad_fnMseLossBackward0)
tensor(0.0493, grad_fnMseLossBackward0)
tensor(0.0491, grad_fnMseLossBackward0)
tensor(0.0488, grad_fnMseLossBackward0)
tensor(0.0485, grad_fnMseLossBackward0)
tensor(0.0482, grad_fnMseLossBackward0)
tensor(0.0479, grad_fnMseLossBackward0)
tensor(0.0476, grad_fnMseLossBackward0)
tensor(0.0473, grad_fnMseLossBackward0)
tensor(0.0470, grad_fnMseLossBackward0)
tensor(0.0468, grad_fnMseLossBackward0)
tensor(0.0465, grad_fnMseLossBackward0)
tensor(0.0462, grad_fnMseLossBackward0)
tensor(0.0459, grad_fnMseLossBackward0)
tensor(0.0456, grad_fnMseLossBackward0)
tensor(0.0454, grad_fnMseLossBackward0)
tensor(0.0451, grad_fnMseLossBackward0)
tensor(0.0448, grad_fnMseLossBackward0)
tensor(0.0446, grad_fnMseLossBackward0)
tensor(0.0443, grad_fnMseLossBackward0)
tensor(0.0440, grad_fnMseLossBackward0)
tensor(0.0438, grad_fnMseLossBackward0)
tensor(0.0435, grad_fnMseLossBackward0)
tensor(0.0432, grad_fnMseLossBackward0)
tensor(0.0430, grad_fnMseLossBackward0)
tensor(0.0427, grad_fnMseLossBackward0)
tensor(0.0425, grad_fnMseLossBackward0)
tensor(0.0422, grad_fnMseLossBackward0)
tensor(0.0420, grad_fnMseLossBackward0)
tensor(0.0417, grad_fnMseLossBackward0)
tensor(0.0415, grad_fnMseLossBackward0)
tensor(0.0412, grad_fnMseLossBackward0)数据集准备 x_train, y_train训练迭代 梯度清零 optimize.zero_grad()前向传播计算损失反向传播更新参数
