使用pytorch进行张量计算、自动求导和神经网络构建功能

目录

• 张量计算
• 张量的属性和方法，如何使用它们来获取或修改张量的信息和形状
• 张量之间的运算和广播机制，如何使用torch.add(), torch.sub(), torch.mul(), torch.div()等函数或者运算符来实现
• 张量与numpy数组之间的互相转换和共享内存机制
• 自动求导
• 什么是计算图，如何使用.grad_fn属性来查看张量在计算图中的位置和函数
• 什么是叶子节点和非叶子节点，如何使用.is_leaf属性来判断张量是否为叶子节点
• 什么是梯度累加机制，如何使用.zero_grad()方法或者with torch.no_grad()语句来清除或禁止梯度累加
• 神经网络的构建

首先，让我们介绍一下什么是pytorch，它是一个基于python的开源深度学习框架qABgCf，它提供了两个核心功能：张量计算和自动求导。

张量计算

张量计算是指使用多维数组（称为张量）来表示和处理数据，例如标量、向量、矩阵等。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'>

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() # 将http://www.devze.come转换为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 forwardjs(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_开发者_C入门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官方网站

到此这篇关于使用pytorch进行张量计算、自动求导和神经网络构建的文章就介绍到这了,更多相关pytorch进行张量计算内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！