---

---

一、认识PyTorch

1.1 PyTorch是什么

PyTorch是一个基于Python的深度学习框架，它提供了一种灵活、高效、易于学习的方式来实现深度学习模型。PyTorch最初由Facebook开发，被广泛应用于计算机视觉、自然语言处理、语音识别等领域。

​ PyTorch使用张量（tensor）来表示数据，可以轻松地处理大规模数据集，且可以在GPU上加速。

​ PyTorch提供了许多高级功能，如**自动微分（automatic differentiation）、自动求导（automatic gradients）**等，这些功能可以帮助我们更好地理解模型的训练过程，并提高模型训练效率。

除了PyTorch，还有很多其它常见的深度学习框架：

1. TensorFlow： Google开发，广泛应用于学术界和工业界。TensorFlow提供了灵活的构建、训练和部署功能，并支持分布式计算。
2. Keras： Keras是一个高级神经网络API，已整合到TensorFlow中。
3. PaddlePaddle： PaddlePaddle（飞桨）是百度推出的开源深度学习平台，旨在为开发者提供一个易用、高效的深度学习开发框架。
4. MXNet：由亚马逊开发，具有高效的分布式训练支持和灵活的混合编程模型。
5. Caffe：具有速度快、易用性高的特点，主要用于图像分类和卷积神经网络的相关任务。
6. CNTK ：由微软开发的深度学习框架，提供了高效的训练和推理性能。CNTK支持多种语言的接口，包括Python、C++和C#等。
7. Chainer：由Preferred Networks开发的开源深度学习框架，采用动态计算图的方式。

PyTorch中有3种数据类型：浮点数、整数、布尔。其中，浮点数和整数又分为8位、16位、32位、64位，加起来共9种。

之所以分为8位、16位、32位、64位，是因为在不同场景中，对数据的精度和速度要求不同。通常，移动或嵌入式设备追求速度，对精度要求相对低一些。精度越高，往往效果也越好，自然硬件开销就比较高。

1.2 安装PyTorch

首先需要使用Anaconda创建一个虚拟环境，建议所使用的python版本不要低于3.8。

conda create -n 你的环境名 python=3.9

如果你是使用的电脑没有独立显卡，或者使用的不是NVIDA的显卡的话，那么只需要安装CPU版本的PyTorch即可。在官方文档里面找到适合你设备的PyTorch的CPU版本及对应的安装指令执行即可。

具体安装步骤可以参考这篇文档：PyTorch安装教程

二、认识Tensor

Tensor，也叫张量，是一个多维数组，通俗来说可以看作是扩展了标量、向量、矩阵的更高维度的数组。张量的维度决定了它的形状（Shape），PyTorch会将数据封装成张量（Tensor）进行计算，所谓张量就是元素为相同类型的多维矩阵。张量可以在 GPU 上加速运行。

张量有device(所属设备)、dtype(数据类型)、shape(形状)等常见属性，知道这些属性对我们认识Tensor很有帮助。

2.1 创建Tensor

2.1.1 基本方式

张量可以通过标量、numpy数组以及list进行创建。

• torch.tensor()
  注意这里的tensor是小写，该API是根据指定的数据创建张量。

import torch
import numpy as np# 通过标量创建
t = torch.tensor(1)
print(t)# 通过ndarray创建
t = torch.tensor(np.random.randn(3, 5))
print(t)# 使用Tensor创建
t = torch.Tensor([1,2,3])
print(t)

如果出现如下错误：

UserWarning: Failed to initialize NumPy: _ARRAY_API not found

一般是因为numpy和pytorch版本不兼容，可以降低numpy版本。

• torch.Tensor
  注意这里的Tensor是大写，该API根据形状创建张量，其也可用来创建指定数据的张量。

# 1. 根据形状创建张量
tensor1 = torch.Tensor(2, 3)
print(tensor1)
# 2. 也可以是具体的值
tensor2 = torch.Tensor([[1, 2, 3], [4, 5, 6]])
print(tensor2, tensor2.shape, tensor2.dtype)tensor3 = torch.Tensor([10])
print(tensor3, tensor3.shape, tensor3.dtype)# 指定tensor数据类型
tensor1 = torch.Tensor([1,2,3]).short()
print(tensor1)tensor1 = torch.Tensor([1,2,3]).int()
print(tensor1)tensor1 = torch.Tensor([1,2,3]).float()
print(tensor1)tensor1 = torch.Tensor([1,2,3]).double()
print(tensor1)

torch.Tensor与torch.tensor区别

特性	torch.Tensor()	torch.tensor()
数据类型推断	强制转为 torch.float32	根据输入数据自动推断（如整数→int64）
显式指定 dtype	不支持	支持（如 dtype=torch.float64）
设备指定	不支持	支持（如 device='cuda'）
输入为张量时的行为	创建新副本（不继承原属性）	默认共享数据（除非 copy=True）
推荐使用场景	需要快速创建浮点张量	需要精确控制数据类型或设备

还有诸如torch.IntTensor()、torch.FloatTensor()、 torch.DoubleTensor()、
torch.LongTensor()…等用于创建指定类型的张量。如果数据类型不匹配，那么在创建的过程中会进行类型转换，要尽可能避免，防止数据丢失。

2.2.2 创建线性和随机张量

• 线性张量
  使用torch.arange 和 torch.linspace 创建线性张量：

# 不用科学计数法打印
torch.set_printoptions(sci_mode=False)# 1. 创建线性张量
r1 = torch.arange(0, 10, 2)
print(r1)
# 2. 在指定空间按照元素个数生成张量：等差
r2 = torch.linspace(3, 10, 10)
print(r2)r2 = torch.linspace(3, 10000000, 10)
print(r2)

• 随机张量
  在 PyTorch 中，使用torch.randn 创建随机张量。种子影响所有与随机性相关的操作，包括张量的随机初始化、数据的随机打乱、模型的参数初始化等。通过设置随机数种子，可以做到模型训练和实验结果在不同的运行中进行复现。也即是说，不设置随机种子时，每次打印的结果不一样。

 # 设置随机数种子
torch.manual_seed(123)# 获取随机数种子
print(torch.initial_seed())# 生成随机张量，均匀分布（范围 [0, 1)）
# 创建2个样本，每个样本3个特征
print(torch.rand(2, 3))# 4. 生成随机张量：标准正态分布（均值 0，标准差 1）
print(torch.randn(2, 3))# 5. 原生服从正态分布：均值为2， 方差为3，形状为1*4的正态分布
print(torch.normal(mean=2, std=3, size=(1, 4)))

2.2 Tensor属性

2.2.1 切换设备

默认在cpu上运行，可以显式的切换到GPU：

# 获取属性
data = torch.tensor([1, 2, 3])
print(data.dtype, data.device, data.shape)# 把数据切换到GPU进行运算
device = "cuda" if torch.cuda.is_available() else "cpu"
data = data.to(device)
print(data.device)

不同设备上的数据是不能相互运算的。

或者使用cuda进行切换：

data = data.cuda()

当然也可以直接创建在GPU上：

# 直接在GPU上创建张量
data = torch.tensor([1, 2, 3], device='cuda')
print(data.device)

2.2.2 类型转换

训练模型或推理时，类型转换也是张量的基本操作，是需要掌握的。

data = torch.tensor([1, 2, 3])
print(data.dtype)  # torch.int64# 1. 使用type进行类型转换
data = data.type(torch.float32)
print(data.dtype)  # float32
data = data.type(torch.float16)
print(data.dtype)  # float16# 2. 使用类型方法
data = data.float()
print(data.dtype)  # float32
# 16 位浮点数，torch.float16，即半精度
data = data.half()
print(data.dtype)  # float16
data = data.double()
print(data.dtype)  # float64
data = data.long()
print(data.dtype)  # int64
data = data.int()
print(data.dtype)  # int32#  使用dtype属性
data = torch.tensor([1, 2, 3], dtype=torch.half)
print(data.dtype)

2.3 Tensor与Numpy的数据转换

2.3.1 张量转ndarray

用于需要计算的情景，转换后即脱离了计算图。此时分浅拷贝（内存共享）和深拷贝（内存不共享）。

• 浅拷贝
  调用numpy()方法可以把Tensor转换为Numpy，此时内存是共享的。

# 1. 张量转numpy
data_tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])
data_numpy = data_tensor.numpy()
print(type(data_tensor), type(data_numpy))
# 2. 他们内存是共享的
data_numpy[0, 0] = 100
print(data_tensor, data_numpy)

• 深拷贝
  使用copy()方法可以避免内存共享：

# 1. 张量转numpy
data_tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])# 2. 使用copy()避免内存共享
data_numpy = data_tensor.numpy().copy()
print(type(data_tensor), type(data_numpy))# 3. 此时他们内存是不共享的
data_numpy[0, 0] = 100
print(data_tensor, data_numpy)

2.3.2 Numpy转张量

也同样分为浅拷贝和深拷贝。

• 浅拷贝
  from_numpy方法转Tensor默认是内存共享的

# 1. numpy转张量
data_numpy = np.array([[1, 2, 3], [4, 5, 6]])
data_tensor = torch.from_numpy(data_numpy)
print(type(data_tensor), type(data_numpy))# 2. 他们内存是共享的
data_tensor[0, 0] = 100
print(data_tensor, data_numpy)

• 深拷贝
  使用传统的torch.tensor()则内存是不共享的

# 1. numpy转张量
data_numpy = np.array([[1, 2, 3], [4, 5, 6]])
data_tensor = torch.tensor(data_numpy)
print(type(data_tensor), type(data_numpy))# 2. 内存是不共享的
data_tensor[0, 0] = 100
print(data_tensor, data_numpy)

2.4 Tensor常见操作

2.4.1 取值

我们可以把单个元素tensor转换为Python数值，这是非常常用的操作。

data = torch.tensor([[18]])
print(data.item())

注意：

• 和Tensor的维度没有关系，都可以取出来！
• 如果有多个元素则报错；
• 仅适用于CPU张量，如果张量在GPU上，需先移动到CPU

2.4.2 基础运算

常见的加减乘除次方取反开方等各种操作，带有_的方法为原地操作。

# 生成范围 [0, 10) 的 2x3 随机整数张量
data = torch.randint(0, 10, (2, 3))
print(data)
# 元素级别的加减乘除：不修改原始值
print(data.add(1))
print(data.sub(1))
print(data.mul(2))
print(data.div(3))
print(data.pow(2))# 元素级别的加减乘除：修改原始值
data = data.float()
data.add_(1)
data.sub_(1)
data.mul_(2)
data.div_(3.0)
data.pow_(2)
print(data)

2.4.3 点积与叉积

• 点积

也叫矩阵乘法，是线性代数中的一种基本运算，用于将两个矩阵相乘，生成一个新的矩阵。

假设有两个矩阵：

• 矩阵 A的形状为 m×n（m行 n列）。
• 矩阵 B的形状为 n×p（n行 p列）。

矩阵 A和 B的乘积 C=A×B是一个形状为 m×p的矩阵，其中 C的每个元素 Cij，计算 A的第 i行与 B的第 j列的点积。计算公式为：
$$C_{ij}=\sum _{k=1}^n{A}_{ik}\times B_{kj}$$

矩阵乘法运算要求如果第一个矩阵的shape是 (N, M)，那么第二个矩阵 shape必须是 (M, P)，即第一个矩阵的列数必须与第二个矩阵的行数相同，最后两个矩阵点积运算的shape为 (N, P)。

在 PyTorch 中，使用@或者matmul完成Tensor的乘法。

data1 = torch.tensor([[1, 2, 3], [4, 5, 6]
])
data2 = torch.tensor([[3, 2], [2, 3], [5, 3]
])
print(data1 @ data2)
print(data1.matmul(data2))

• 叉积

也叫阿达玛积，是指两个形状相同的矩阵或张量对应位置的元素相乘。它与矩阵乘法不同，矩阵乘法是线性代数中的标准乘法，而阿达玛积是逐元素操作。假设有两个形状相同的矩阵 A和 B，它们的阿达玛积 C=A∘B定义为：
$$C_{ij}=A_{ij}\times B_{ij}$$
其中：

• Cij 是结果矩阵 C的第 i行第 j列的元素。
• Aij和 Bij分别是矩阵 A和 B的第 i行第 j 列的元素。

在 PyTorch 中，可以使用mul函数或者*来实现；

data1 = torch.tensor([[1, 2, 3], [4, 5, 6]])
data2 = torch.tensor([[2, 3, 4], [2, 2, 3]])
print(data1 * data2)
print(data1.mul(data2))

2.4.4 形状操作

• reshape
  可以用于将张量转换为不同的形状，但要确保转换后的形状与原始形状具有相同的元素数量。

data = torch.randint(0, 10, (4, 3))
print(data)
# 1. 使用reshape改变形状
data = data.reshape(2, 2, 3)
print(data)# 2. 使用-1表示自动计算
data = data.reshape(2, -1)
print(data)

• view

view进行形状变换的特征：

• 张量在内存中是连续的；
• 返回的是原始张量视图，不重新分配内存，效率更高;
• 如果张量在内存中不连续，view 将无法执行，并抛出错误。

张量的内存布局决定了其元素在内存中的存储顺序。对于多维张量，内存布局通常按照最后一个维度优先的顺序存储，即先存列，后存行。例如，对于一个二维张量
A，其形状为 (m, n)，其内存布局是先存储第 0 行的所有列元素，然后是第 1 行的所有列元素，依此类推。 如果张量的内存布局与形状完全匹配，并且没有被某些操作（如转置、索引等）打乱，那么这个张量就是连续的。

PyTorch 的大多数操作都是基于 C 顺序的，我们在进行变形或转置操作时，很容易造成内存的不连续性。

tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])
print("正常情况下的张量：", tensor.is_contiguous())# 对张量进行转置操作
tensor = tensor.t()
print("转置操作的张量：", tensor.is_contiguous())
print(tensor)
# 此时使用view进行变形操作，取值为-1表示自动推断该维度
tensor = tensor.view(2, -1)
print(tensor)

运行结果如下：

• transpose
  transpose 用于交换张量的两个维度，注意，是2个维度，它返回的是新张量，原张量不变。

torch.transpose(input, dim0, dim1)

参数：

• input: 输入的张量。
• dim0: 要交换的第一个维度。
• dim1: 要交换的第二个维度。

data = torch.randint(0, 10, (3, 4, 5))
print(data, data.shape)
# 使用transpose进行形状变换
transpose_data = torch.transpose(data,0,1)
# transpose_data = data.transpose(0, 1)
print(transpose_data, transpose_data.shape)

转置后的张量可能是非连续的（is_contiguous() 返回 False），如果需要连续内存（如某些操作要求），可调用 .contiguous()：

y = x.transpose(0, 1).contiguous()

• permute
  它通过重新排列张量的维度来返回一个新的张量，不改变张量的数据，只改变维度的顺序。

torch.permute(input, dims)

参数

• input: 输入的张量。
• dims: 一个整数元组，表示新的维度顺序。

data = torch.randint(0, 10, (3, 4, 5))
print(data, data.shape)
# 使用permute进行多维度形状变换
permute_data = data.permute(1, 2, 0)
print(permute_data, permute_data.shape)

和 transpose 一样，permute 返回新张量，原张量不变。重排后的张量可能是非连续的（is_contiguous() 返回 False），必要时需调用 .contiguous()。

维度顺序必须合法：dims 中的维度顺序必须包含所有原始维度，且不能重复或遗漏。例如，对于一个形状为 (2, 3, 4) 的张量，dims=(2, 0, 1) 是合法的，但 dims=(0, 1) 或 dims=(0, 1, 2, 3) 是非法的。

与 transpose() 的对比

特性	permute()	transpose()
功能	可以同时调整多个维度的顺序	只能交换两个维度的顺序
灵活性	更灵活	较简单
使用场景	适用于多维张量	适用于简单的维度交换

2.4.5 升维和降维

• squeeze降维
  用于移除所有大小为 1 的维度，或者移除指定维度的大小为 1 的维度。

torch.squeeze(input, dim=None)

参数

• input: 输入的张量。
• dim (可选): 指定要移除的维度。如果指定了 dim，则只移除该维度（前提是该维度大小为 1）；如果不指定，则移除所有大小为 1 的维度。

data = torch.randint(0, 10, (1, 4, 5, 1))
print(data, data.shape)# 进行降维操作
data1 = data.squeeze(0).squeeze(-1)
print(data.shape)# 移除所有大小为 1 的维度
data2 = torch.squeeze(data)# 尝试移除第 1 维（大小为 3，不为 1，不会报错，张量保持不变。）
data3 = torch.squeeze(data, dim=1)
print("尝试移除第 1 维后的形状:", data3.shape)

• unsqueeze升维

torch.unsqueeze(input, dim)

参数

• input: 输入的张量。
• dim: 指定要增加维度的位置（从 0 开始索引）。

data = torch.randint(0, 10, (32, 32, 3))
print(data.shape)
# 升维操作
data = data.unsqueeze(0)
print(data.shape)

Tensor也有广播机制，且与numpy数组基本一致，这里不再赘述。

---

总结

本文简要介绍了PyTorch，以及Tensor的一部分常用基本操作。