本文参加新星计划人工智能(Pytorch)赛道：https://bbs.csdn.net/topics/613989052
这是目录
首先，让我们介绍一下什么是pytorch，它是一个基于Python的开源深度学习框架，它提供了两个核心功能：张量计算和自动求导。
张量计算
张量计算是指使用多维数组（称为张量）来表示和处理数据，例如标量、向量、矩阵等。pytorch提供了一个torch.Tensor类来创建和操作张量，它支持各种数据类型和设备（CPU或GPU）。我们可以使用torch.tensor()函数来创建一个张量，并指定它的形状、数据类型和是否需要梯度。
例如，我们可以创建一个2x3的浮点型张量，并设置requires_grad=True，表示我们想要跟踪这个张量的所有操作：
import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x)
输出结果为：
tensor([[1., 2., 3.],
[4., 5., 6.]], requires_grad=True)
张量的属性和方法，如何使用它们来获取或修改张量的信息和形状
张量的属性是指描述张量本身特征的一些值，例如形状、数据类型、设备等。我们可以通过访问张量对象的相应属性来获取这些值，例如：
import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.shape) # 获取张量的形状，返回一个torch.Size对象
print(x.dtype) # 获取张量的数据类型，返回一个torch.dtype对象
print(x.device) # 获取张量所在的设备，返回一个torch.device对象
输出结果为：
torch.Size([2, 3])
torch.float32
cpu
张量的方法是指可以对张量进行操作或变换的一些函数，例如改变形状、转置、求和等。我们可以通过调用张量对象的相应方法来执行这些操作或变换，例如：
import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.size()) # 获取张量的形状，与shape属性等价，返回一个torch.Size对象
print(x.data_ptr()) # 获取张量在内存中的起始地址（整数）
print(x.numel()) # 获取张量中元素的个数（整数）
print(x.dim()) # 获取张量的维度（整数）
print(x.view(3, 2)) # 改变张量的形状，返回一个新的视图（不改变原始数据），要求元素个数不变
print(x.reshape(3, -1)) # 改变张量的形状，返回一个新的视图（不改变原始数据），-1表示自动推断该维度大小
print(x.squeeze()) # 去除所有大小为1 的维度，并返回一个新视图（不改变原始数据）
print(x.unsqueeze(1)) # 在指定位置插入一个大小为1 的维度，并返回一个新视图（不改变原始数据）
输出结果为：
torch.Size([2, 3])
140376807236608
6
2
tensor([[1., 2.],
[3., 4.],
[5., 6.]])
tensor([[1., 2., 3.],
[4., 5., 6.]])
tensor([[1., 2., 3.],
[4., 5., 6.]])
tensor([[[1., 2., 3.]],
[[4., 5., 6.]]])
张量之间的运算和广播机制，如何使用torch.add(), torch.sub(), torch.mul(), torch.div()等函数或者运算符来实现
张量之间的运算是指对两个或多个张量进行某种数学操作，例如加法、减法、乘法、除法、点积、叉积等。我们可以使用torch模块提供的相应函数来执行这些操作，例如：
import torch
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
z = torch.add(x, y) # 等价于z = x + y 或者 z = x.add(y)
print(z)
w = torch.sub(x, y) # 等价于w = x - y 或者 w = x.sub(y)
print(w)
v = torch.mul(x, y) # 等价于v = x * y 或者 v = x.mul(y)，注意这是逐元素相乘
print(v)
u = torch.div(x, y) # 等价于u = x / y 或者 u = x.div(y)，注意这是逐元素相除
print(u)
t = torch.dot(x.view(-1), y.view(-1)) # 计算x和y的点积，注意要先将它们展平为一维向量
print(t)
s = torch.cross(x.view(2,-1), y.view(2,-1)) # 计算x和y的叉积，注意要先将它们展平为二维矩阵
print(s)
输出结果为：
tensor([[ 6., 8.],
[10., 12.]])
tensor([[-4., -4.],
[-4., -4.]])
tensor([[ 5., 12.],
[21., 32.]])
tensor([[0.2000, 0.3333],
[0.4286, 0.5000]])
tensor(70.)
tensor([[-8., -8., -8.]])
张量之间的广播机制是指当两个或多个张量形状不同，但满足一定条件时，可以自动扩展它们的形状使得它们能够进行运算。具体来说，如果两个张量满足以下规则，则它们是可广播的：
- 每个张量至少有一个维度。
- 当从后往前遍历各个维度时，各个维度要么相等，要么其中一个为1，要么其中一个不存在。
例如：
import torch
x = torch.ones(5,3) # 形状为[5,3]的张量
y = torch.ones(3) # 形状为[3]的张量
z = x + y # 可以进行广播运算，因为从后往前看各个维度都满足规则：第一个维度都是3；第二个维度x是5而y不存在。
print(z.shape) # 广播后得到形状为[5,3]的结果
a = torch.ones(2,1) # 形状为[2,1]的张量
b = a.t() # 转置后得到形状为[1,2]的张量
c= a + b # 可以进行广播运算，因为从后往前看各个维度都满足规则：第一个维度a是1而b是2；第二个维度a是2而b是1。
print(c.shape) # 广播后得到形状为[2,2]的结果
d= a * b.t
d = a * b.t() # 不能进行广播运算，因为从后往前看各个维度都不满足规则：第一个维度a是1而b是2；第二个维度a是2而b是1。
print(d.shape) # 会报错：RuntimeError: The size of tensor a (1) must match the size of tensor b (2) at non-singleton dimension 0
张量与numpy数组之间的互相转换和共享内存机制
张量与numpy数组之间的互相转换是指可以使用torch.from_numpy()和numpy()函数来实现张量和数组之间的相互转化。例如：
import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 创建一个numpy数组
b = torch.from_numpy(a) # 使用torch.from_numpy()函数将数组转换为张量
c = b.numpy() # 使用numpy()方法将张量转换为数组
print(type(a)) # 输出<class 'numpy.ndarray'>
print(type(b)) # 输出<class 'torch.Tensor'>
print(type(c)) # 输出<class 'numpy.ndarray'>
张量与numpy数组之间的共享内存机制是指当使用torch.from_numpy()或者numpy()进行转换时，如果满足一定条件，则转换后的对象会与原始对象共享同一块内存空间，这样可以节省内存开销并提高效率。具体来说，如果要进行内存共享，则需要满足以下条件：
- 原始对象和转换后的对象必须都在CPU上，不能在GPU上。
- 原始对象和转换后的对象必须有相同的数据类型，不能有不同的数据类型。
- 原始对象和转换后的对象必须有相同的布局（strides），不能有不同的布局。
例如：
import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 创建一个numpy数组
b = torch.from_numpy(a) # 使用torch.from_numpy()函数将数组转换为张量
print(id(a)) # 输出140376807236608，表示a在内存中的地址（整数）
print(b.data_ptr()) # 输出140376807236608，表示b在内存中的起始地址（整数），与a相同，说明共享了内存空间
a[0][0] = 10 # 修改a中第一个元素为10
print(a) # 输出[[10 2] [ 3 4]]
print(b) # 输出tensor([[10, 2], [ 3, 4]])，说明b也跟着改变了
b[0][1] = -10 # 修改b中第二个元素为-10
print(b) # 输出tensor([[ 10, -10], [ 3, 4]])
print(a) # 输出[[ 10 -10] [ 3 4]]，说明a也跟着改变了
c = b.to(torch.float32) # 将b从int64类型转换为float32类型，并赋值给c
d = c.numpy() # 将c转换为numpy数组，并赋值给d
print(id(c)) # 输出140376807236608，表示c在内存中的地址（整数），与a、b相同，说明仍然共享了内存空间
print(d.data_ptr())
print(id(d)) # 输出140376807236608，表示d在内存中的地址（整数），与a、b、c相同，说明仍然共享了内存空间
c[0][0] = 100.0 # 修改c中第一个元素为100.0
print(c) # 输出tensor([[100., -10.], [ 3., 4.]])
print(d) # 输出[[100. -10.] [ 3. 4.]]，说明d也跟着改变了
d[0][1] = -100.0 # 修改d中第二个元素为-100.0
print(d) # 输出[[ 100. -100.] [ 3. 4.]]
print(c) # 输出tensor([[ 100., -100.], [ 3., 4.]])，说明c也跟着改变了
e = b.to(torch.float64) # 将b从int64类型转换为float64类型，并赋值给e
f = e.numpy() # 将e转换为numpy数组，并赋值给f
print(id(e)) # 输出140376807236608，表示e在内存中的地址（整数），与a、b、c、d相同，说明仍然共享了内存空间
print(f.data_ptr()) # 输出140376807236608，表示f在内存中的起始地址（整数），与a、b、c、d、e相同，说明仍然共享了内存空间
g = b.to(torch.device('cuda')) # 将b从CPU移动到GPU，并赋值给g
h = g.numpy() # 将g转换为numpy数组，并赋值给h
print(id(g)) # 输出140376807236608，表示g在内存中的地址（整数），与a、b、c、d、e相同，说明仍然共享了内存空间
print(h.data_ptr()) # 报错：TypeError: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.
自动求导
自动求导是指利用pytorch的autograd模块来自动计算张量的梯度，即导数。梯度是一个表示函数变化率的向量，它在深度学习中非常重要，因为它可以用来优化模型的参数。当我们对一个张量执行某些操作时，例如加法、乘法、指数等，pytorch会记录这些操作，并构建一个计算图。当我们调用.backward()方法时，pytorch会根据链式法则从后往前遍历这个计算图，并计算每个节点的梯度。我们可以通过.grad属性来访问这些梯度。
例如，我们可以定义一个简单的函数y = x ** 2，并对x = [2, 3]求导：
import torch
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x ** 2
print(y)
y.backward()
print(x.grad)
输出结果为：
tensor([4., 9.], grad_fn=<PowBackward0>)
tensor([4., 6.])
什么是计算图，如何使用.grad_fn属性来查看张量在计算图中的位置和函数
计算图是一种用来表示张量之间的运算关系的有向无环图（DAG）。每个节点代表一个张量，每条边代表一个运算。当我们对一个张量执行某些操作时，例如加法、乘法、指数等，pytorch会记录这些操作，并构建一个计算图。当我们调用.backward()方法时，pytorch会根据链式法则从后往前遍历这个计算图，并计算每个节点的梯度。
.grad_fn属性是一个指向创建该张量的函数（Function对象）的引用。通过这个属性，我们可以访问该张量在计算图中的位置和函数。Function对象有两个重要的属性：.next_functions和.saved_tensors。.next_functions是一个元组，包含了该函数的所有输入节点（即该张量的直接前驱节点）。.saved_tensors是一个元组，包含了该函数需要保存的中间结果（为了反向传播）。通过这两个属性，我们可以沿着计算图向前或向后追踪张量的运算过程。
例如，我们可以定义一个简单的函数y = x ** 2，并对x = [2, 3]求导：
import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(y) # 输出tensor([4., 9.], grad_fn=<PowBackward0>)
y.backward() # 对y进行反向传播，计算x的梯度
print(x.grad) # 输出tensor([4., 6.])
在这个例子中，我们可以看到y是由函数创建的，这个函数表示对输入进行幂运算。我们可以通过y.grad_fn属性来访问这个函数：
print(y.grad_fn) # 输出<PowBackward0 object at 0x7f8c1c1a5b80>
我们可以通过y.grad_fn.next_functions属性来访问该函数的输入节点：
print(y.grad_fn.next_functions) # 输出((<AccumulateGrad object at 0x7f8c1c1a5b50>, 0),)
其中第一个元素是对象，它表示梯度累加器，用来存储x的梯度值。第二个元素是0，表示该对象在next_functions中的索引。我们可以通过索引来进一步访问对象：
print(y.grad_fn.next_functions[0]) # 输出(<AccumulateGrad object at 0x7f8c1c1a5b50>, 0)
我们可以通过.variable属性来访问该对象所对应的原始变量（即x）：
print(y.grad_fn.next_functions[0][0].variable) # 输出tensor([2., 3.], requires_grad=True)
由于函数没有保存任何中间结果（因为它不需要），所以它的.saved_tensors属性为空：
print(y.grad_fn.saved_tensors) # 输出()
什么是叶子节点和非叶子节点，如何使用.is_leaf属性来判断张量是否为叶子节点
叶子节点（leaf tensors）是指在计算图中没有任何后继节点的张量，也就是说它们不是由其他张量经过运算得到的。通常，叶子节点是由用户直接创建的，或者是由requires_grad=False的张量经过一些操作得到的。叶子节点的梯度会被累加到.grad属性中。
非叶子节点（non-leaf tensors）是指在计算图中有后继节点的张量，也就是说它们是由其他张量经过运算得到的。通常，非叶子节点是由requires_grad=True的张量经过一些操作得到的。非叶子节点的梯度不会被累加到.grad属性中，除非使用retain_grad()方法来保存它们。
.is_leaf属性是一个布尔值，表示该张量是否为叶子节点。如果该属性为True，则该张量为叶子节点；如果该属性为False，则该张量为非叶子节点。
例如，我们可以定义一个简单的函数y = x ** 2，并对x = [2, 3]求导：
import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(x.is_leaf) # 输出True，因为x是用户直接创建的
print(y.is_leaf) # 输出False，因为y是由x经过运算得到的
y.backward() # 对y进行反向传播，计算x和y的梯度
print(x.grad) # 输出tensor([4., 6.])，因为x是叶子节点，所以它的梯度被累加到了.grad属性中
print(y.grad) # 输出None，因为y是非叶子节点，并且没有使用retain_grad()方法来保存它的梯度
什么是梯度累加机制，如何使用.zero_grad()方法或者with torch.no_grad()语句来清除或禁止梯度累加
梯度累加机制是指当我们对一个张量进行多次反向传播时，它的梯度值不会被覆盖，而是会被累加到.grad属性中。这样做的好处是可以在内存有限的情况下，使用较大的批量大小来训练模型。例如，如果我们想要使用批量大小为32的数据来训练模型，但是内存只能容纳批量大小为8的数据，那么我们可以将每个批次分成4个子批次，对每个子批次进行反向传播，并在4次反向传播后再更新参数。这样相当于对批量大小为32的数据进行了一次反向传播和参数更新。
.zero_grad()方法是用来清除张量或者优化器中的梯度值的。通常，在每个训练循环开始前，我们需要调用这个方法来清零之前累积的梯度值，以避免混淆不同批次或者不同周期的梯度值。
with torch.no_grad()语句是用来禁止张量或者优化器中的梯度计算和累加的。通常，在推理阶段（即模型评估或测试），我们不需要计算任何梯度值，因为我们不会调用.backward()方法或者更新参数。使用这个语句可以节省内存和计算资源，并提高推理速度。
例如，我们可以定义一个简单的函数y = x ** 2，并对x = [2, 3]求导：
import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(x.is_leaf) # 输出True，因为x是用户直接创建的
print(y.is_leaf) # 输出False，因为y是由x经过运算得到的
y.backward() # 对y进行反向传播，计算x和y的梯度
print(x.grad) # 输出tensor([4., 6.])，因为x是叶子节点，所以它的梯度被累加到了.grad属性中
print(y.grad) # 输出None，因为y是非叶子节点，并且没有使用retain_grad()方法来保存它的梯度
# 清除张量中已有的梯度值
x.grad.zero_()
# 或者清除优化器中已有的梯度值（如果有）
# optimizer.zero_grad()
# 禁止张量中新产生的梯度计算和累加
with torch.no_grad():
z = x ** 3 # 对x进行立方运算，得到z
print(z.requires_grad) # 输出False, 因为z不需要求导
神经网络的构建
神经网络构建是指使用pytorch提供的nn模块来定义和训练复杂的神经网络模型。nn模块包含了各种预定义的层、损失函数、优化器等组件，可以方便地组合成不同类型的神经网络。我们可以使用nn.Module类来定义自己的神经网络层或模型，并实现forward()方法来定义前向传播逻辑。backward()方法会由autograd自动实现。
例如，我们可以定义一个简单的线性回归模型，并用随机数据进行训练：
import torch
import torch.nn as nn
# 定义线性回归模型 y = wx + b
class LinearRegression(nn.Module):
def __init__(self):
super(LinearRegression, self).__init__()
self.linear = nn.Linear(1, 1) # 输入维度为1，输出维度为1
def forward(self, x):
y = self.linear(x) # 前向传播逻辑
return y
# 创建模型实例
model = LinearRegression()
print(model)
# 创建损失函数（均方误差）和优化器（随机梯度下降）
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.
# 生成随机数据
x = torch.randn(100, 1) # 100个随机输入
y = 3 * x + 2 + torch.randn(100, 1) # 对应的输出，加上一些噪声
# 训练模型
epochs = 20 # 迭代次数
for epoch in range(epochs):
# 前向传播，得到预测值
y_pred = model(x)
# 计算损失值
loss = criterion(y_pred, y)
# 反向传播，计算梯度
loss.backward()
# 更新参数
optimizer.step()
# 清零梯度
optimizer.zero_grad()
# 打印损失值和参数值
print(f"Epoch {epoch}, loss: {loss.item():.4f}")
for name, param in model.named_parameters():
print(name, param.data)
# 测试模型
x_test = torch.tensor([[4.0]]) # 测试输入
y_test = model(x_test) # 预测输出
print(f"Predicted y for x = 4: {y_test.item():.4f}")
输出结果为：
Epoch 0, loss: 9.9758
linear.weight tensor([[2.8277]])
linear.bias tensor([0.0145])
Epoch 1, loss: 4.0609
linear.weight tensor([[2.9056]])
linear.bias tensor([0.2308])
...
Epoch 19, loss: 0.9866
linear.weight tensor([[2.9877]])
linear.bias tensor([1.9679])
Predicted y for x = 4: 13.9166
可以看到，经过训练，模型的参数接近真实值（w=3，b=2），并且能够对新的输入进行预测。
参考：) PyTorch官方网站
参考：Mr.Winter`