PyTorch 基础操作

什么是 PyTorch?

PyTorch 是一个开源机器学习和深度学习框架。

可以使用 PyTorch 编写代码、处理数据，编写机器学习和深度学习算法。

世界上许多大型公司，如 Meta (Facebook)，特斯拉和微软，以及人工智能研究公司，如 OpenAI use PyTorch 都使用 PyTorch 研究机器学习算法，并将算法落地到他们的产品中。

例如，Andrej Karpathy（特斯拉 AI 负责人）进行了多次关于自动驾驶计算机视觉模型的演讲，(PyTorch DevCon 2019, Tesla AI Day 2021) 分享了特斯拉使用了 PyTorch 推动计算机视觉模型的发展。PyTorch 还用于农业等其他行业，为拖拉机上的计算机视觉提供动力。

为什么使用 PyTorch?

机器学习研究人员喜欢使用 PyTorch。截至 2022 年 2 月，PyTorch 是 Papers With Code 上最常用的深度学习框架，该网站用于跟踪机器学习研究论文及其附带的代码存储库。

PyTorch 还有 GPU 加速，使代码运行得更快，你可以专注于操作数据和编写算法。

本文分享的内容

目录	内容
张量简介	张量是所有机器学习和深度学习的基本构建块。
创建张量	张量几乎可以表示任何类型的数据（图像、文字、数字表格）。
从张量中获取信息	可以将信息放入张量，也可以把它取出来。
操纵张量	机器学习算法（如神经网络）涉及以许多不同的方式操纵张量，例如加法、乘法、组合。
处理张量形状	机器学习中最常见的问题之一是处理形状不匹配（试图将错误形状的张量与其他张量混合）。
张量索引	我们可以在 Python 列表或 NumPy 数组上建立索引，张量索引与它们非常相似，只是张量索引可以有更多的维度。
混合 PyTorch 张量和 NumPy	PyTorch 使用张量 (torch.Tensor), NumPy 使用数组 (np.ndarray) 有时想要混合搭配这些。
再现性	机器学习是非常实验性的，因为它使用大量的随机性来工作，有时我们会希望随机性不要那么随机。
在 GPU 上运行张量	GPU（图形处理单元）使代码更快，PyTorch 可以轻松地在 GPU 上运行代码。

本文来源

项目地址在 GitHub，https://github.com/mrdbourke/pytorch-deep-learning.

如果阅读英文无压力，建议阅读原文，若想先中文预览一下，继续看下去吧！本文在原文基础上加入了一些思考。

如果遇到困难也可以在讨论页面上提问：https://github.com/mrdbourke/pytorch-deep-learning/discussions

PyTorch 开发者论坛：https://discuss.pytorch.org/

Kaggle 练习地址

原项目有 Google Colab 的练习地址，考虑方便性，搬运到了 Kaggle 平台，进行了汉化，仅用于学习。‍

https://www./zymzym/pytorch-fundamentals-00

PyTorch 基础知识

导入 PyTorch

注意: 如果在本地的设备运行代码，需先安装 PyTorch。在 Kaggle 平台或是 Google Colab 上运行，一切都应该正常（它们附带安装了 PyTorch 和其他库）。

设置好 GPU，让我们导入 PyTorch 并检查使用的版本。

Kaggle 设置

张量简介

现在我们已经导入了 PyTorch，是时候了解张量了。

张量是机器学习的基本构建块。工作方式是以数字方式表示数据。

例如， 读者可以将图像表示为张量，形状为 [3, 224, 224] ，每个数分别表示为[colour_channels, height, width]。图像有 3 个颜色通道（分别是红色、绿色、蓝色）， 像素高度和宽度都是 224 。

上图展示的图像张量，具有三个维度，对于不了解 PyTorch ,这些知识有些超前，接下来，通过代码了解更多的内容。

创建张量

提供官网关于张量的文档，感兴趣可以阅读完本文之后继续扩展：https://pytorch.org/docs/stable/tensors.html

我们要创建的第一个变量是标量（Scalar）。

标量是一个单一的数字，用张量的语言来说，它是一个零维张量。

看看上面打印出来的 tensor(7)，这意味着 scalar 是一个数字，类型是torch.Tensor。

我们可以使用 ndim 检查张量的维度。

如果我们想从张量中检索数字怎么办？例如把它从 torch.Tensor 变成一个 Python 整数?

我们可以使用 item() 方法。

Okay， 现在让我们看一个 vector （向量）。

向量是一维张量，但可以包含许多数字。

就像房子一样可以用一个矢量 [3, 2] 描述 [bedrooms, bathrooms] 的数量，或者用 [3, 2, 2] 描述 [bedrooms, bathrooms, car_parks] 。

现在vector 有两个 7。你认为它有多少维度？

嗯，这很奇怪，vector 包含两个数字但只有一个维度。

在 PyTorch 中，可以通过外面方括号  ([) 的数量来判断一个张量的维数，只需要计算一侧的方括号有几个。

张量的另一个重要概念是它们的shape（形状） 属性. 形状告诉我们张量中的元素是如何排列的。

我们来看看 vector 的形状。

上面的torch.Size([2]) 意味着形状是 [2]. 因为我们在方括号内放了两个元素 ([7, 7]).

现在让我们看一个 matrix（矩阵）。

哇！更多数字！矩阵和向量一样灵活，除了它们有一个额外的维度。

MATRIX 有两个维度（数过一侧方括号的数量吗？）。

读者认为 shape 是什么样的?

我们得到输出 torch.Size([2, 2])， MATRIX 有 2 行和 2 列。

我们来创建一个 tensor（张量）?

哇！多么漂亮的张量。

张量几乎可以代表任何东西。

我们刚刚创建的那个可能是一家牛排和杏仁黄油店的销售数字。

读者认为它有多少维度？（提示：使用方括号计数技巧）

那它的形状呢？

输出是 torch.Size([1, 3, 3])，形状是从外向内，这意味着有 1 个 3 x 3 的维度。

注意: 你可能已经注意到我们用小写字母描述 scalar 和 vector，使用大写字母描述 MATRIX 和 TENSOR。在实践中，我们将会看到标量和向量表示为小写字母，例如 y 或 a。矩阵和张量表示为大写字母，如 X 或 W.

让我们总结一下。

名称	它是什么？	维度	常见命名方式
scalar 标量	一个数字	0	a
vector 向量	一个带方向的数字（例如带方向的风速），但也可以有许多其他数字	1	y
matrix 矩阵	二维数组	2	Q
tensor 张量	一个 n 维数组	可以是任意数，0维张量是标量，1维张量是向量	X

随机张量

我们已经确定张量代表某种形式的数据。机器学习中的神经网络使用张量操作数据。但在使用 PyTorch 构建机器学习模型时，我们很少会手动创建 tenor。

相反，机器学习模型通常从大量随机数字张量开始，并在处理数据时调整这些随机数字以更好地表示它。

在本质上：

Start with random numbers -> look at data -> update random numbers -> look at data -> update random numbers...

作为数据科学家，会定义机器学习模型如何启动（初始化）、查看数据（表示）和更新（优化）其随机数。

稍后我们将着手处理这些步骤。

现在，让我们看看如何创建随机数张量。

我们可以使用 torch.rand() 创建并传入参数 size。

torch.rand() 具有灵活性，通过 size 调整维度。

例如我们创建一个常见的图像张量 [224, 224, 3] ([height, width, color_channels])。

全为 0 的张量和全为 1 的张量

当我们想用 0 屏蔽一个张量中的某些值，让模型知道不要学习它们时，会创建全为 0 的张量。torch.zeros() 可以用来创建一个充满 0 的张量。参数 size 会发挥作用。

torch.ones()  可以用来创建一个充满 1 的张量。

创建一个在定义范围内的张量

有时可能需要一个数字范围，例如 1 到 10 或 0 到 100。可以使用 torch.arange(start, end, step) 来创建。

其中:

• start = 起始的范围 (例如：0)
• end = 结束的 (例如：10)
• step = 每个数字之间间隔多少 (例如：1)

注意: 在 Python 中，可以使用 range() 来创建范围。但是在 PyTorch 中， torch.range() 已被弃用，若使用时会显示运行错误。

有时可能希望某种类型的一个张量与另一个张量具有相同的形状。例如，一个全零张量想与前一个张量具有相同形状。为此，读者可以使用torch.zeros_like(input) or torch.ones_like(input) ，参数input ， 传入期望形状一样的张量。

张量数据类型

PyTorch 中有许多不同的张量数据类型可用。有些特定于 CPU，有些则更适合 GPU。了解哪个是哪个可能需要一些时间，更多内容可以阅读。https://pytorch.org/docs/stable/tensors.html#data-types

一般来说，如果你在任何地方看到 torch.cuda ，张量都被用于 GPU（因为 Nvidia GPU 被称为 CUDA 的计算工具包）。

最常见的类型是 torch.float32 or torch.float，被称为“32 位浮点数”。但也有 16 位浮点数 (torch.float16 or torch.half) 和 64 位浮点数 (torch.float64 or torch.double)。

更令人困惑的是，还有 8 位、16 位、32 位和 64 位整数。

注意: 7 是整数，浮点数表示为7.0。

两个数字的区别与计算精度有关。精度是用于描述数字的详细程度。精度值（8、16、32）越高，用于表达数字的细节和数据就越多。

这在深度学习和数值计算中很重要，因为你要进行如此多的操作，你需要计算的细节越多，你必须使用的计算就越多。

因此，较低精度的数据类型通常计算速度更快，但会牺牲一些评估指标的性能，例如准确性（计算速度更快但准确性较低）。

扩展资料:

• 有关所有可用张量数据类型的列表，请参阅PyTorch 文档，https://pytorch.org/docs/stable/tensors.html#data-types
• 阅读维基百科页面，了解什么是计算精度，https://en./wiki/Precision_(computer_science)

让我们看看如何创建一些具有特定数据类型的张量，可以使用 dtype 查看数据类型。

除了形状问题（张量形状不匹配）之外，我们在 PyTorch 中遇到的另外两个最常见的问题是数据类型和设备问题。

如，一个张量是 torch.float32 另一个是 torch.float16 （PyTorch 喜欢张量是相同的格式）。

或者你的一个张量在 CPU 上，另一个在 GPU 上（PyTorch 喜欢在同一设备上进行张量之间的计算）。

稍后我们会看到更多关于此设备的讨论。

现在让我们用 dtype=torch.float16 创建张量。

从张量中获取信息

当你创建了张量（或者其他人还是 PyTorch 模块已经创建了它们），我们可能想要从它们那里获取一些信息。

我们之前已经见过这些，了解关于张量的三个最常见的属性是：

• shape - 张量是什么形状？（有些操作需要特定的形状规则）
• dtype - 张量中的元素存储在什么数据类型中？
• device - 张量存储在什么设备上？（通常是 GPU 或 CPU）

让我们创建一个随机张量并找出有关它的详细信息。

张量运算

在深度学习中，数据（图像、文本、视频、音频、蛋白质结构等）被表示为张量。

模型通过研究这些张量并对张量执行一系列操作（可能超过 1,000,000 次）来学习，来表示输入数据中的关系。

这些操作往往是:

• 加法
• 减法
• 按照元素相乘
• 除法
• 矩阵乘法

就是这样。当然还有更多，但这些是神经网络的基本构建块。我们可以用正确的方式堆叠这些构建块，来创建最复杂的神经网络。（就像乐高一样！）

基本操作

让我们从一些基本运算开始，加法  (+)， 减法(-)， 乘法 (*)。

注意上面的张量值最终并没有变成 tensor([110, 120, 130])，这是因为张量内部的值只有重新分配才会改变。

让我们减去一个数字，这次我们将重新分配 tensor 变量。

PyTorch 也有一堆内置函数，比如 torch.mul() （multiplcation 的缩写） 和 torch.add() 执行基本操作。

但是，更常见的是使用运算符符号是 * 而不是 torch.mul()

矩阵乘法

机器学习和深度学习算法（如神经网络）中最常见的操作之一是矩阵乘法 matrix multiplication。

PyTorch 在 torch.matmul() 方法中实现矩阵乘法功能。

要记住的矩阵(行，列)乘法的两个主要规则：

1. 内部尺寸必须匹配：

• (3, 2) @ (3, 2) 第一个矩阵的列数与第二个数组的行数尺寸不一致
• (2, 3) @ (3, 2) 尺寸一致，正常执行
• (3, 2) @ (2, 3) 尺寸一致，正常执行

2. 生成的矩阵具有外部维度的形状:

• (2, 3) @ (3, 2) -> (2, 2) 生成形状是第一个矩阵的行数和第二个矩阵的列数
• (3, 2) @ (2, 3) -> (3, 3)

注意: Python中的 '@' 是矩阵乘法的符号。

文档: 在 PyTorch 文档中可查看矩阵乘法的所有规则，https://pytorch.org/docs/stable/generated/torch.matmul.html

让我们创建一个张量并对其执行逐元素乘法和矩阵乘法。

逐元素乘法和矩阵乘法的区别在于值的相加。

对于 tensor 变量值为 [1, 2, 3]:

操作	数学计算	代码
按元素乘法	[1*1, 2*2, 3*3] = [1, 4, 9]	tensor * tensor
矩阵乘法	[1*1 + 2*2 + 3*3] = [14]	tensor.matmul(tensor)

处理张量形状

深度学习中最常见的错误之一（形状错误）

由于大部分深度学习都是在矩阵上进行乘法和运算，而矩阵对可以组合的形状和大小有严格的规定，因此在深度学习中遇到的最常见错误之一是形状不匹配。

可以通过使它们的内部维度匹配来使矩阵乘法在tensor_A 和 tensor_B 之间起作用。

一种方法是使用 转置 transpose （变换给定张量的维度）。

我们可以使用以下任一方法在 PyTorch 中执行转置：

• torch.transpose(input, dim0, dim1) - 其中 input 是需要转置的张量， dim0 和 dim1 是要交换的维度。
• tensor.T - 其中 tensor 是需要转置的张量。

让我们试试第二种。

也可以使用 torch.mm() 是 torch.matmul() 的缩写。

矩阵乘法的视觉效果如下：

创建自己的矩阵乘法视觉效果地址，http:///

注意: 像这样的矩阵乘法也称为两个矩阵的点积 dot product

神经网络充满了矩阵乘法和点积。

该 torch.nn.Linear() 模块也称为前馈层或全连接层，它在输入 x 和权重矩阵 A 之间实现矩阵乘法。

其中:

• x 是该层的输入 (度学习是一堆类似torch.nn.Linear() 的层和其他层彼此叠加）。
• A i是由该层创建的权重矩阵，它以随机数开始，随着神经网络学习更好地表示数据中的关系而进行调整 (注意 'T'， 是因为权重矩阵被转置)。
• 注意: 您可能还会经常看另一个类似用于表示权重矩阵的字母 W 或X。
• b 是用于稍微抵消权重和输入的偏差项。
• y 是输出（对输入的操作以发现两者之间的关系）。

这是一个线性函数 (读者可能在高中已经看到类似 )，并且可以用来画一条直线！

让我们玩一个线性层。

尝试更改 in_features 和 out_features 的值，看看会发生什么。

查找最小值、最大值、平均值、总和等

现在我们已经看到了几种操作张量的方法，让我们来看看其他方法（从更多的值到更少的值）。

首先，我们将创建一个张量，然后找到它的最大值、最小值、平均值和总和。

注意: 读者可能会发现一些方法，例如 torch.mean() 要求张量是 torch.float32 （最常见的）或其他特定数据类型，否则操作将失败。

同样可以使用torch 方法。

位置最小值/最大值

读者还可以找到张量的索引，其中最大值或最小值分别出现在 torch.argmax() 和torch.argmin() 。

如果读者想要最高（或最低）值所在的位置而不是实际值本身，在后面的部分会使用softmax activation function)做到。

更改张量数据类型

深度学习操作的一个常见问题是张量具有不同的数据类型。

如果一个张量在  torch.float64 中而另一个在torch.float32 中，可能会遇到一些错误，有一个解决办法。

可以使用 torch.Tensor.type(dtype=None) 来更改张量的数据类型。其中参数 dtype 是数据类型。

首先，我们将创建一个张量并检查它的数据类型(默认为 torch.float32)。

现在我们将创建另一个与之前相同的张量，但将其数据类型更改为 torch.float16。

可以做类似的事情来制作 torch.int8 张量。

注意: 开始时可能会混淆不同的数据类型。但是可以这样想，数字越小（例如 32、16、8），计算机存储的值就越不精确。如果存储量较少，这通常会导致更快的计算速度和更小的整体模型。基于移动设备的神经网络通常使用 8 位整数进行运算，该整数更小且运行速度更快，但不如 float32 准确。有关这方面的更多信息，可以阅读https://en./wiki/Precision_(computer_science)

Reshaping, stacking, squeezing and unsqueezing

很多时候读者会想要改变张量的维度而不改变它们内部的值。

常见的方法是：

方法	说明
torch.reshape(input, shape)	改变 input 的维度为 shape (如果适合)，也可以使用 torch.Tensor.reshape().
torch.Tensor.view(shape)	张量的维度变为 shape，返回的张量与原始张量共享数据。
torch.stack(tensors, dim=0)	tensors 沿新维度 (dim)连接一系列序列，所有序列的tensors 大小必须相同。
torch.squeeze(input)	移除input 维度为1 的行或者列。
torch.unsqueeze(input, dim)	添加 input 维度为1 的行或者列。
torch.permute(input, dims)	input 的维度根据 dims 重新排列，若赋予新的张量与原始张量共享数据

为什么要做这些？

因为深度学习模型（神经网络）都是关于以某种方式操纵张量的。由于矩阵乘法的规则，如果形状不匹配，就会出错。这些方法可帮助您将张量的正确元素与其他张量的正确元素混合。

让我们试试看。

首先，我们将创建一个张量。

现在让我们添加一个额外的维度 torch.reshape()。

我们还可以使用 torch.view() 更改维度。

但请记住，使用 torch.view() 改变张量的视图复制给新变量，实际上只会创建相同张量。改变此新变量的值，原始变量的值也会相应改变。

如果我们想将新张量叠加在自身之上五次，我们可以使用 torch.stack()。

如何从张量中删除所有单一维度？可以使用torch.squeeze() (移除维度为 1 的行或列)。

要执行torch.squeeze() 的相反的操作， 可以使用 torch.unsqueeze() 在特定索引处添加维度值 1。

读者还可以使用 torch.permute(input, dims) 重新排列每个维度的顺序， 其中 input 维度变为dims，赋予的新张量会与原始张量共享数据。

注意: 因为置换返回一个新张量（与原始张量共享相同的数据），置换后新张量中的值将与原始张量相同，如果您更改新张量，它将更改原始张量的值。

索引（从张量中挑选数据）

有时会希望从张量中选择特定数据（例如，仅第一列或第二行），可以使用索引。

如果读者曾经在 Python 列表或 NumPy 数组上进行过索引，那么在 PyTorch 中使用张量进行索引非常相似。

索引值为外部维度 -> 内部维度（检查方括号）。

可以使用: 来指定“此维度中的所有值”，然后使用逗号 (,) 添加另一个维度。

索引一开始可能会很混乱，尤其是对于较大的张量，对于有经验的人仍然需要多次尝试索引才能正确。

PyTorch 张量和 NumPy

由于 NumPy 是一种流行的 Python 数值计算库，因此 PyTorch 具有与其良好交互的功能。

从 NumPy 到 PyTorch（并再次返回），使用的两种主要方法是：

• torch.from_numpy(ndarray) - NumPy 数组 -> PyTorch 张量。
• torch.Tensor.numpy() - PyTorch 张量 -> NumPy 数组。

让我们试试看。

注意: 默认情况下，NumPy 数组是使用数据类型创建的float64，如果将其转换为 PyTorch 张量，它将保持相同的数据类型（如上所述）。

但是，许多 PyTorch 计算默认使用 float32.

所以如果你想转换你的 NumPy 数组 (float64) -> PyTorch 张量 (float64) -> PyTorch 张量 (float32)，可以使用 tensor = torch.from_numpy(array).type(torch.float32).

因为 tensor 会重新分配，如果改变张量，数组保持不变。

如果想从 PyTorch 张量到 NumPy 数组，可以调用tensor.numpy()。

同样，如果改变原始的 tensor，新的 numpy_tensor 不会改变。

再现性（试图从随机中取出随机）

随着读者对神经网络和机器学习的了解越来越多，将会发现随机性的作用有多大。在计算机中这里的随机是伪随机性。因为随机性是被设计的，计算机基本上是确定性的（每一步都是可预测的），所以它们创建的随机性是模拟随机性。

那么这与神经网络和深度学习有什么关系呢？

我们讨论了神经网络从随机数开始描述数据中的关系，并尝试使用张量操作，改进这些随机数以更好地描述数据中的关系。

简而言之：

start with random numbers -> tensor operations -> try to make better (again and again and again)

尽管随机性很好也很强大，但有时我们希望随机性少一点。

为什么？

因此我们可以进行可重复的实验。

这就是再现性的用武之地。

换句话说，读者能在自己的计算机上运行与其他人的代码，并且获得相同（或非常相似）的结果吗？

让我们看一个 PyTorch 中可再现性的简短示例。

我们将从创建两个随机张量开始，因为它们是随机的，读者会认为它们是不同的吗？

正如读者预料的那样，张量具有不同的值。但是如果想创建两个具有相同值的随机张量怎么办。

这就需要 torch.manual_seed(seed) , 其中 seed 是一个整数。

在 GPU 上运行张量（并进行更快的计算）

深度学习算法需要大量的数值运算。

默认情况下，这些操作通常在 CPU（计算机处理单元）上完成。

然而，还有另一种常见的硬件，称为 GPU（图形处理单元），它在执行神经网络所需的特定类型的操作（矩阵乘法）时通常比 CPU 快得多。

有几种方法可以首先访问 GPU，然后让 PyTorch 使用 GPU。

若在 Kaggle（注册需要外网） 或是 Google Colab（一直需要外网） 平台上运行代码，可以开启 GPU 设置。

1. 获得 GPU

如果没有，有几种方法可以访问其中一个。

• Google Colab 或 Kaggle
  Kaggle Notebook 快速上手
  Google Colab 快速上手

  Google Colab 官方文档：https://colab.research.google.com/notebooks/gpu.ipynb

• 自己具备 GPU

  PyTorch 官方安装文档：https://pytorch.org/get-started/locally/

  如果想要购买自己的 GPU 但不确定要买什么，Tim Dettmers 有一个很好的指南， https:///2020/09/07/which-gpu-for-deep-learning/

要检查是否可以访问 Nvidia GPU，可以 !nvidia-smi ，其中 ! 表示“在命令行上运行”的地方运行。

如果没有可访问的 Nvidia GPU，上面的内容将输出如下内容：

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.


2. 让 PyTorch 在 GPU 上运行

一旦准备好访问 GPU，下一步就是让 PyTorch 用于存储数据（张量）和计算数据（对张量执行操作）。为此，可以使用该 torch.cuda 包。

可以使用 torch.cuda.is_available()测试 PyTorch 是否可以访问 GPU 。

如果以上输出 True，可以看到 GPU 设备，如果它输出False，则看不到 GPU。这种情况下确保是否设备有 GPU，若有则配置好 GPU 环境。

现在，假设你想要设置代码，使其在可用的 CPU 或 GPU 上运行。这样，如果其他人运行你的代码时，无论他们使用何种计算设备，代码都可以正常工作。

让我们创建一个 device 变量来存储可用的设备类型。

如果上面的输出 'cuda' 意味着我们可以将 PyTorch 代码设置为使用可用的 CUDA 设备（GPU），如果它输出 'cpu' 表示 PyTorch 代码使用的 CPU。

注意: 在 PyTorch 中，编写与设备无关的代码非常方便。这意味着代码将根据设备情况在 CPU 或 GPU（如果可用）上运行。https://pytorch.org/docs/master/notes/cuda.html#device-agnostic-code

如果想做更快的计算，可以使用一个 GPU，但如果想做更快的计算，可以使用多个 GPU。

使用 torch.cuda.device_count() 可以计算 PyTorch 可用的 GPU 数量。

了解 PyTorch 可用的 GPU 数量，可以让一个特定进程在一个 GPU 上运行，而在另一个 GPU 上运行另一个进程（PyTorch 还能让所有GPU 上运行一个进程）。

3. 将张量（和模型）放在 GPU 上

可以通过 to(device) 把张量和模型放在特定设备上。其中 device 是设备配置。

为什么要这样做？

GPU 提供比 CPU 快得多的数值计算，如果 GPU 不可用，由于 设备不可知，它将在 CPU 上运行。

注意: 使用 to(device) 将张量放在 GPU 上 (例如 some_tensor.to(device)) 会返回该张量的副本，例如，相同的张量将在 CPU 和 GPU 上。如果想使用原张量的命名，重新给原命名赋值。

some_tensor = some_tensor.to(device)

让我们尝试创建一个张量并将其放在 GPU 上（如果可用）。

请注意，第二个张量有 device='cuda:0'，这意味着它存储在第 0 个可用的 GPU 上（GPU 的索引为 0，如果有两个 GPU 可用，它们分别为 'cuda:0' 和 'cuda:1' ，最多为 'cuda:n')。

4. 将张量移回 CPU

如果想使用 NumPy 与张量进行交互（NumPy 不利用 GPU），将需要执行以下操作。

让我们使用 torch.Tensor.numpy() 方法在 tensor_on_gpu 上。

相反，要将张量返回给 CPU 并可用于 NumPy，可以使用Tensor.cpu()。

这会将张量复制到 CPU 内存，因此它可用于 CPU。

以上返回在 CPU 内存中 GPU 张量的副本，因此原始张量仍在 GPU 上。

点击👇卡片关注我，第一时间获取干货～