Pytorch ：张量（Tensor）详解

已于 2024-08-29 10:00:02 修改
阅读量1.6k 收藏 24
点赞数 20
分类专栏： pytorch 文章标签： pytorch 人工智能 python
于 2024-08-29 09:53:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fydw_715/article/details/141643617
版权

张量的基本概念

张量（Tensor）是数学和计算中的一个核心概念，广泛应用于物理学、工程学、计算机科学等领域，特别是在机器学习和深度学习中。张量可以被看作是一个多维数组，能够表示标量、向量、矩阵以及更高维度的数据结构。

张量的定义
  1. 标量 (0阶张量): 一个单一的数值，如 3.14 或 42。
  2. 向量 (1阶张量): 一个一维数组，如 [1, 2, 3]。
  3. 矩阵 (2阶张量): 一个二维数组，如 [[1, 2], [3, 4]]。
  4. 高阶张量: 三维或更高维度的数组，如一个三维张量可以表示为 [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]。

张量可以在不同的维度上进行操作，如加法、乘法、转置等。它们是高效数值计算的基础，特别是在涉及大量数据和复杂计算的场景中。

张量在计算中的角色
  • 数据表示: 张量用于表示输入数据、权重、偏置等各种数据结构。
  • 计算操作: 张量操作（如加法、乘法、卷积等）是深度学习模型训练和推理的核心。
  • 自动微分: 许多深度学习框架（如TensorFlow和PyTorch）利用张量及其操作实现自动微分，从而简化了梯度计算过程。
张量 vs NumPy 数组

NumPy 是一个广泛使用的Python库，用于科学计算。NumPy数组（ndarray）和张量有很多相似之处，但也有一些关键差异。

相似性
  1. 多维数组: 两者都可以表示多维数组。
  2. 基本操作: 两者都支持基本的数学运算，如加法、乘法、转置等。
  3. 索引与切片: 两者都支持索引和切片操作，允许访问和修改数组的部分内容。
  4. 广播机制: 两者都支持广播机制，允许对不同形状的数组进行操作。
差异性

  1. 计算设备:

    • NumPy数组: 通常在CPU上进行计算。
    • 张量: 可以在CPU和GPU上进行计算。GPU通常在处理大规模并行计算时表现更优异。

  2. 框架集成:

    • NumPy数组: 主要用于一般科学计算和数据处理。
    • 张量: 深度学习框架（如TensorFlow和PyTorch）中的核心数据结构，专门用于构建和训练神经网络。

  3. 自动微分:

    • NumPy数组: 不支持自动微分。
    • 张量: 深度学习框架中的张量支持自动微分，有助于梯度计算和优化。

  4. API与操作:

    • NumPy数组: 提供了丰富的科学计算API，但缺乏一些深度学习所需的高级操作。
    • 张量: 提供了专门针对深度学习的API，如卷积、池化、激活函数等。
张量在GPU上的计算优势
  1. 并行计算: GPU擅长处理大量并行计算任务。张量操作可以利用GPU的并行处理能力，大大加速计算速度。
  2. 大规模数据处理: 在训练大型深度学习模型时，GPU可以显著减少训练时间。
  3. 优化库支持: 许多深度学习框架和库（如CuDNN、CuBLAS）都对GPU进行了优化，使得张量操作在GPU上更高效。

快速开始

为了更好地理解张量的概念以及它与NumPy数组的相似性和差异性，下面通过一些具体的示例来展示张量的基本操作、在GPU上的计算优势以及与NumPy数组的比较。

示例 1: 张量的基本操作

我们使用PyTorch来展示张量的基本操作。

import torch

# 创建一个标量张量
scalar = torch.tensor(3.14)
print("标量:", scalar)

# 创建一个向量张量
vector = torch.tensor([1, 2, 3])
print("向量:", vector)

# 创建一个矩阵张量
matrix = torch.tensor([[1, 2], [3, 4]])
print("矩阵:", matrix)

# 创建一个三维张量
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("三维张量:", tensor_3d)
示例 2: 张量 vs NumPy 数组

我们比较张量和NumPy数组的基本操作。

import numpy as np

# 创建一个NumPy数组
np_array = np.array([[1, 2], [3, 4]])
print("NumPy数组:\n", np_array)

# 创建一个等价的PyTorch张量
torch_tensor = torch.tensor([[1, 2], [3, 4]])
print("PyTorch张量:\n", torch_tensor)

# 基本操作示例：加法
np_add = np_array + np_array
torch_add = torch_tensor + torch_tensor
print("NumPy数组加法:\n", np_add)
print("PyTorch张量加法:\n", torch_add)
示例 3: 张量在GPU上的计算

我们展示如何在GPU上进行张量计算。

# 检查是否有GPU可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 创建一个在CPU上的张量
cpu_tensor = torch.tensor([[1, 2], [3, 4]])
print("CPU张量:", cpu_tensor)

# 将张量移动到GPU上
gpu_tensor = cpu_tensor.to(device)
print("GPU张量:", gpu_tensor)

# 在GPU上进行计算
result = gpu_tensor + gpu_tensor
print("在GPU上进行加法计算结果:", result)
示例 4: 自动微分

我们展示如何使用PyTorch的自动微分功能。

# 创建一个需要梯度的张量
x = torch.tensor(2.0, requires_grad=True)

# 定义一个函数
y = x**2 + 3*x + 2

# 计算梯度
y.backward()

# 打印梯度
print("x的梯度:", x.grad)
示例 5: 广播机制

我们展示张量的广播机制。

# 创建两个形状不同的张量
tensor_a = torch.tensor([[1, 2, 3], [4, 5, 6]])
tensor_b = torch.tensor([1, 2, 3])

# 广播机制进行加法
result = tensor_a + tensor_b
print("广播机制结果:\n", result)

创建张量

创建张量是理解和使用张量的基础操作之一。在PyTorch中，可以从多种数据结构创建张量，包括Python列表、元组和NumPy数组。下面详细介绍这些方法，并给出具体的示例。

从 Python 列表创建张量

你可以直接从Python列表创建张量。PyTorch会自动推断数据的类型和形状。

import torch

# 从标量创建张量
scalar_tensor = torch.tensor(3.14)
print("标量张量:", scalar_tensor)

# 从一维列表创建张量（向量）
vector_tensor = torch.tensor([1, 2, 3])
print("向量张量:", vector_tensor)

# 从二维列表创建张量（矩阵）
matrix_tensor = torch.tensor([[1, 2], [3, 4]])
print("矩阵张量:", matrix_tensor)

# 从三维列表创建张量
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("三维张量:", tensor_3d)
从 Python 元组创建张量

类似于从列表创建张量，你也可以从元组创建张量。

# 从一维元组创建张量（向量）
vector_tensor = torch.tensor((1, 2, 3))
print("向量张量:", vector_tensor)

# 从二维元组创建张量（矩阵）
matrix_tensor = torch.tensor(((1, 2), (3, 4)))
print("矩阵张量:", matrix_tensor)

# 从三维元组创建张量
tensor_3d = torch.tensor((((1, 2), (3, 4)), ((5, 6), (7, 8))))
print("三维张量:", tensor_3d)
从 NumPy 数组创建张量

PyTorch提供了方便的方法将NumPy数组转换为张量。这对于在NumPy和PyTorch之间进行互操作非常有用。

import numpy as np

# 创建一个NumPy数组
np_array = np.array([[1, 2], [3, 4]])
print("NumPy数组:\n", np_array)

# 将NumPy数组转换为PyTorch张量
torch_tensor = torch.tensor(np_array)
print("从NumPy数组创建的张量:\n", torch_tensor)
其他创建张量的方法

除了从数据结构创建张量，PyTorch还提供了一些其他方法来创建特定类型的张量，例如全零张量、全一张量、随机张量等。除了全零张量、全一张量、随机张量和单位矩阵张量，PyTorch还提供了许多其他便捷的方法来创建张量。下面是一些常见的方法和它们的具体示例：

1. 创建全零张量和全一张量
import torch

# 创建一个全零张量
zeros_tensor = torch.zeros((2, 3))
print("全零张量:\n", zeros_tensor)

# 创建一个全一张量
ones_tensor = torch.ones((2, 3))
print("全一张量:\n", ones_tensor)
2. 创建随机张量
# 创建一个均匀分布的随机张量
uniform_tensor = torch.rand((2, 3))
print("均匀分布的随机张量:\n", uniform_tensor)

# 创建一个标准正态分布的随机张量
normal_tensor = torch.randn((2, 3))
print("标准正态分布的随机张量:\n", normal_tensor)
3. 创建单位矩阵张量
# 创建一个3x3的单位矩阵张量
identity_tensor = torch.eye(3)
print("单位矩阵张量:\n", identity_tensor)
4. 创建特定值的张量
# 创建一个所有元素都为指定值的张量
full_tensor = torch.full((2, 3), 7)
print("所有元素都为7的张量:\n", full_tensor)
5. 创建序列张量
# 创建一个包含从0到n-1的序列张量
arange_tensor = torch.arange(0, 10, step=2)
print("包含从0到9的序列张量（步长为2）:\n", arange_tensor)

# 创建一个线性间隔的张量
linspace_tensor = torch.linspace(0, 1, steps=5)
print("包含从0到1的线性间隔的张量（5个元素）:\n", linspace_tensor)
6. 创建对角线张量
# 创建一个对角线张量
diagonal_tensor = torch.diag(torch.tensor([1, 2, 3]))
print("对角线张量:\n", diagonal_tensor)
7. 通过克隆和填充创建张量
# 克隆一个张量
original_tensor = torch.tensor([[1, 2], [3, 4]])
cloned_tensor = original_tensor.clone()
print("克隆的张量:\n", cloned_tensor)

# 用特定值填充张量
filled_tensor = torch.empty((2, 3)).fill_(5)
print("用5填充的张量:\n", filled_tensor)
8. 创建空张量
# 创建一个未初始化的张量
empty_tensor = torch.empty((2, 3))
print("未初始化的张量:\n", empty_tensor)
9. 从其他张量创建张量
# 创建一个与给定张量形状相同的全零张量
like_zeros_tensor = torch.zeros_like(original_tensor)
print("与给定张量形状相同的全零张量:\n", like_zeros_tensor)

# 创建一个与给定张量形状相同的全一张量
like_ones_tensor = torch.ones_like(original_tensor)
print("与给定张量形状相同的全一张量:\n", like_ones_tensor)

# 创建一个与给定张量形状相同的随机张量
like_rand_tensor = torch.rand_like(original_tensor)
print("与给定张量形状相同的随机张量:\n", like_rand_tensor)
10. 创建复数张量
# 创建一个复数张量
complex_tensor = torch.tensor([1 + 2j, 3 + 4j])
print("复数张量:\n", complex_tensor)

张量的属性

张量的属性是理解和操作张量的关键。主要的张量属性包括形状（shape）、数据类型（dtype）和设备（device）。下面详细介绍这些属性，并给出具体的示例。

1. 形状（shape）

张量的形状表示张量在每个维度上的大小。形状是一个描述张量结构的重要属性，可以通过 .shape 属性查看。

查看张量的形状
import torch

# 创建一个2x2的张量
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print("张量 x 的形状:", x.shape)  # 输出: torch.Size([2, 2])
修改张量的形状

可以使用 .view() 或 .reshape() 方法来改变张量的形状。

# 使用 .view() 修改形状
reshaped_x = x.view(4)
print("使用 .view() 修改形状后的张量:", reshaped_x)  # 输出: tensor([1., 2., 3., 4.])

# 使用 .reshape() 修改形状
reshaped_x = x.reshape(4)
print("使用 .reshape() 修改形状后的张量:", reshaped_x)  # 输出: tensor([1., 2., 3., 4.])

# 修改为三维张量
reshaped_x = x.view(2, 2, 1)
print("修改为三维张量后的形状:", reshaped_x.shape)  # 输出: torch.Size([2, 2, 1])
2. 数据类型（dtype）

张量的数据类型（dtype）决定了张量中元素的数据类型。PyTorch支持多种数据类型，如浮点型（float）、整型（int）等。

查看张量的数据类型
# 创建一个浮点型张量
x = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
print("张量 x 的数据类型:", x.dtype)  # 输出: torch.float32
转换张量的数据类型

可以使用 .to() 方法或直接指定 dtype 属性来转换张量的数据类型。

# 将浮点型张量转换为整型张量
x = x.to(torch.int64)
print("转换后的数据类型:", x.dtype)  # 输出: torch.int64
print("转换后的张量:", x)  # 输出: tensor([1, 2, 3])

# 另一种转换方法
x = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
x = x.type(torch.int64)
print("使用 type() 转换后的数据类型:", x.dtype)  # 输出: torch.int64
print("使用 type() 转换后的张量:", x)  # 输出: tensor([1, 2, 3])
3. 设备（device）

张量可以存储在不同的设备上，如CPU或GPU。了解张量所在的设备对于高效计算和资源管理非常重要。

查看张量所在的设备
# 创建一个在GPU上的张量（假设有CUDA支持）
x = torch.tensor([1.0, 2.0, 3.0], device='cuda')
print("张量 x 所在的设备:", x.device)  # 输出: cuda:0
将张量移动到不同设备

可以使用 .to() 方法将张量移动到不同的设备。

# 将张量移动到CPU
x = x.to('cpu')
print("移动到CPU后的设备:", x.device)  # 输出: cpu

# 将张量移动到GPU
if torch.cuda.is_available():
    x = x.to('cuda')
    print("移动到GPU后的设备:", x.device)  # 输出: cuda:0
综合示例

下面是一个综合示例，展示如何查看和修改张量的形状、数据类型和设备。

import torch

# 创建一个2x2的浮点型张量，并将其放在GPU上（如果有CUDA支持）
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32, device='cuda' if torch.cuda.is_available() else 'cpu')

# 查看张量的形状、数据类型和设备
print("张量的形状:", x.shape)  # 输出: torch.Size([2, 2])
print("张量的数据类型:", x.dtype)  # 输出: torch.float32
print("张量的设备:", x.device)  # 输出: cuda:0 或 cpu

# 修改张量的形状
reshaped_x = x.view(4)
print("修改后的形状:", reshaped_x.shape)  # 输出: torch.Size([4])

# 转换张量的数据类型
x = x.to(torch.int64)
print("转换后的数据类型:", x.dtype)  # 输出: torch.int64

# 将张量移动到不同设备
x = x.to('cpu')
print("移动后的设备:", x.device)  # 输出: cpu

张量操作

张量操作是使用张量进行计算的核心部分。掌握基本的算术运算、索引和切片、形状变换以及拼接和拆分是处理张量数据的基础。下面我们详细介绍这些操作，并提供具体示例。

1. 基本算术运算
张量加法

张量加法是对两个形状相同的张量进行逐元素相加。

import torch

x = torch.tensor([1.0, 2.0, 3.0])
y = torch.tensor([4.0, 5.0, 6.0])

# 张量加法
z = x + y
print("张量加法结果:", z)  # 输出: tensor([5., 7., 9.])

你也可以使用 torch.add() 函数来进行加法运算。

z = torch.add(x, y)
print("使用 torch.add() 的加法结果:", z)  # 输出: tensor([5., 7., 9.])
张量减法

张量减法是对两个形状相同的张量进行逐元素相减。

# 张量减法
z = x - y
print("张量减法结果:", z)  # 输出: tensor([-3., -3., -3.])

你也可以使用 torch.sub() 函数来进行减法运算。

z = torch.sub(x, y)
print("使用 torch.sub() 的减法结果:", z)  # 输出: tensor([-3., -3., -3.])
张量逐元素乘法

张量逐元素乘法是对两个形状相同的张量进行逐元素相乘。

# 张量逐元素乘法
z = x * y
print("张量逐元素乘法结果:", z)  # 输出: tensor([ 4., 10., 18.])

你也可以使用 torch.mul() 函数来进行逐元素乘法运算。

z = torch.mul(x, y)
print("使用 torch.mul() 的逐元素乘法结果:", z)  # 输出: tensor([ 4., 10., 18.])
张量逐元素除法

张量逐元素除法是对两个形状相同的张量进行逐元素相除。

# 张量逐元素除法
z = x / y
print("张量逐元素除法结果:", z)  # 输出: tensor([0.2500, 0.4000, 0.5000])

你也可以使用 torch.div() 函数来进行逐元素除法运算。

z = torch.div(x, y)
print("使用 torch.div() 的逐元素除法结果:", z)  # 输出: tensor([0.2500, 0.4000, 0.5000])
2. 索引和切片
张量索引

张量索引用于获取张量中的某个具体元素。

# 创建一个2x2的张量
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 获取第0行第1列的元素
y = x[0, 1]
print("张量索引结果:", y)  # 输出: tensor(2.)
张量切片

张量切片用于获取张量的一个子张量。

# 获取张量的第二列
z = x[:, 1]
print("张量切片结果:", z)  # 输出: tensor([2., 4.])

你还可以结合多种索引和切片方式来获取复杂的子张量。

# 获取张量的第一行和第二列的元素
w = x[0, :]
print("张量的第一行:", w)  # 输出: tensor([1., 2.])

# 获取张量的第二行和第一列的元素
v = x[1, 0]
print("张量的第二行第一列的元素:", v)  # 输出: tensor(3.)
3. 形状变换
使用 view 改变张量形状

view 方法用于改变张量的形状，但要求新的形状与原始数据的总元素数量相同。

# 创建一个2x2的张量
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 改变张量形状为1维
y = x.view(4)
print("使用 view 改变形状后的张量:", y)  # 输出: tensor([1., 2., 3., 4.])
使用 reshape 改变张量形状

reshape 方法与 view 类似，但更灵活，能够处理非连续存储的数据。

# 改变张量形状为1维
y = x.reshape(4)
print("使用 reshape 改变形状后的张量:", y)  # 输出: tensor([1., 2., 3., 4.])
使用 transpose 转置张量

transpose 方法用于交换张量的两个维度。

# 转置张量
z = x.transpose(0, 1)
print("转置后的张量:\n", z)  # 输出: tensor([[1., 3.], [2., 4.]])
使用 permute 变换张量维度

permute 方法用于对张量的维度进行任意排列。

# 创建一个3维张量
x = torch.randn(2, 3, 4)

# 变换张量维度
y = x.permute(2, 0, 1)
print("使用 permute 变换维度后的张量形状:", y.shape)  # 输出: torch.Size([4, 2, 3])
4. 拼接和拆分
使用 cat 拼接张量

cat 方法用于沿指定维度拼接多个张量。

# 创建两个2x2的张量
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.tensor([[5.0, 6.0], [7.0, 8.0]])

# 沿第0维拼接
z = torch.cat((x, y), dim=0)
print("沿第0维拼接后的张量:\n", z)  # 输出: tensor([[1., 2.], [3., 4.], [5., 6.], [7., 8.]])

# 沿第1维拼接
z = torch.cat((x, y), dim=1)
print("沿第1维拼接后的张量:\n", z)  # 输出: tensor([[1., 2., 5., 6.], [3., 4., 7., 8.]])
使用 stack 堆叠张量

stack 方法用于沿新维度拼接多个张量。

# 堆叠张量
w = torch.stack((x, y), dim=0)
print("堆叠后的张量:\n", w)  # 输出: tensor([[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]]])
使用 split 拆分张量

split 方法用于将一个张量拆分为多个子张量。

# 创建一个1x8的张量
x = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])

# 将张量拆分为每个子张量长度为2的多个子张量
splits = torch.split(x, 2)
print("拆分后的张量:")
for tensor in splits:
    print(tensor)
# 输出:
# tensor([1, 2])
# tensor([3, 4])
# tensor([5, 6])
# tensor([7, 8])
总结

通过上述详细的说明和示例，我们展示了如何进行基本的张量算术运算、索引和切片、形状变换以及拼接和拆分。这些操作在实际应用中非常常见和重要，理解和掌握这些操作能够显著提升你在使用PyTorch进行深度学习和科学计算时的效率和能力。希望这些示例能帮助你更好地理解张量的操作。

数学运算

数学运算是张量操作中的核心部分，掌握基本数学函数、聚合操作和逐元素操作对于处理和分析张量数据至关重要。下面我们详细介绍这些操作，并提供具体示例。

1. 基本数学函数

PyTorch 提供了许多常见的数学函数，如指数函数、对数函数、正弦函数、余弦函数等。

指数函数
import torch

x = torch.tensor([1.0, 2.0, 3.0])
y = torch.exp(x)  # 计算e的x次幂
print("指数函数结果:", y)  # 输出: tensor([ 2.7183,  7.3891, 20.0855])
对数函数
y = torch.log(x)  # 计算自然对数
print("对数函数结果:", y)  # 输出: tensor([0.0000, 0.6931, 1.0986])
正弦函数
y = torch.sin(x)  # 计算正弦值
print("正弦函数结果:", y)  # 输出: tensor([0.8415, 0.9093, 0.1411])
余弦函数
y = torch.cos(x)  # 计算余弦值
print("余弦函数结果:", y)  # 输出: tensor([ 0.5403, -0.4161, -0.9900])
2. 聚合操作

聚合操作用于对张量进行汇总计算，如求和、均值、最大值、最小值等。

求和
x = torch.tensor([1.0, 2.0, 3.0])
y = torch.sum(x)  # 计算所有元素的和
print("求和结果:", y)  # 输出: tensor(6.)
求均值
y = torch.mean(x)  # 计算所有元素的均值
print("求均值结果:", y)  # 输出: tensor(2.)
求最大值
y = torch.max(x)  # 计算所有元素的最大值
print("求最大值结果:", y)  # 输出: tensor(3.)
求最小值
y = torch.min(x)  # 计算所有元素的最小值
print("求最小值结果:", y)  # 输出: tensor(1.)
维度上的聚合操作

你还可以指定维度进行聚合操作。

# 创建一个2x3的张量
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

# 沿第0维求和
y = torch.sum(x, dim=0)
print("沿第0维求和结果:", y)  # 输出: tensor([5., 7., 9.])

# 沿第1维求均值
y = torch.mean(x, dim=1)
print("沿第1维求均值结果:", y)  # 输出: tensor([2., 5.])
3. 逐元素操作

逐元素操作用于对张量的每个元素进行独立的计算，如绝对值、平方根、幂运算等。

绝对值
x = torch.tensor([-1.0, 2.0, -3.0])
y = torch.abs(x)  # 计算每个元素的绝对值
print("绝对值结果:", y)  # 输出: tensor([1., 2., 3.])
平方根
x = torch.tensor([1.0, 4.0, 9.0])
y = torch.sqrt(x)  # 计算每个元素的平方根
print("平方根结果:", y)  # 输出: tensor([1., 2., 3.])
幂运算
x = torch.tensor([1.0, 2.0, 3.0])
y = torch.pow(x, 2)  # 计算每个元素的平方
print("幂运算结果:", y)  # 输出: tensor([1., 4., 9.])

你也可以使用 ** 运算符进行幂运算。

y = x ** 2  # 计算每个元素的平方
print("使用 ** 运算符的幂运算结果:", y)  # 输出: tensor([1., 4., 9.])
综合示例

下面是一个综合示例，展示如何使用基本数学函数、聚合操作和逐元素操作。

import torch

# 创建一个张量
x = torch.tensor([1.0, 2.0, 3.0])

# 基本数学函数
exp_x = torch.exp(x)
log_x = torch.log(x)
sin_x = torch.sin(x)
cos_x = torch.cos(x)

print("指数函数结果:", exp_x)  # 输出: tensor([ 2.7183,  7.3891, 20.0855])
print("对数函数结果:", log_x)  # 输出: tensor([0.0000, 0.6931, 1.0986])
print("正弦函数结果:", sin_x)  # 输出: tensor([0.8415, 0.9093, 0.1411])
print("余弦函数结果:", cos_x)  # 输出: tensor([ 0.5403, -0.4161, -0.9900])

# 聚合操作
sum_x = torch.sum(x)
mean_x = torch.mean(x)
max_x = torch.max(x)
min_x = torch.min(x)

print("求和结果:", sum_x)  # 输出: tensor(6.)
print("求均值结果:", mean_x)  # 输出: tensor(2.)
print("求最大值结果:", max_x)  # 输出: tensor(3.)
print("求最小值结果:", min_x)  # 输出: tensor(1.)

# 逐元素操作
abs_x = torch.abs(x)
sqrt_x = torch.sqrt(x)
pow_x = torch.pow(x, 2)

print("绝对值结果:", abs_x)  # 输出: tensor([1., 2., 3.])
print("平方根结果:", sqrt_x)  # 输出: tensor([1., 1.4142, 1.7321])
print("幂运算结果:", pow_x)  # 输出: tensor([1., 4., 9.])
总结

通过上述详细的说明和示例，我们展示了如何进行基本的数学函数、聚合操作和逐元素操作。这些操作在实际应用中非常常见和重要，理解和掌握这些操作能够显著提升你在使用PyTorch进行深度学习和科学计算时的效率和能力。希望这些示例能帮助你更好地理解张量的数学运算。

线性代数运算

线性代数是深度学习和科学计算中的重要组成部分，掌握矩阵运算、矩阵分解和求解线性方程组等操作对于处理和分析数据非常关键。下面我们详细介绍这些操作，并提供具体示例。

1. 矩阵运算
矩阵乘法

矩阵乘法是线性代数中的基本运算之一。PyTorch 提供了 torch.matmul() 函数来进行矩阵乘法。

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.matmul(x, y)
print("矩阵乘法结果:\n", z)
# 输出:
# tensor([[19., 22.],
#         [43., 50.]])

你也可以使用 @ 运算符来进行矩阵乘法运算。

z = x @ y
print("使用 @ 运算符的矩阵乘法结果:\n", z)
# 输出:
# tensor([[19., 22.],
#         [43., 50.]])
矩阵求逆

矩阵求逆是线性代数中的另一个重要运算。PyTorch 提供了 torch.inverse() 函数来进行矩阵求逆。

# 矩阵求逆
inv_x = torch.inverse(x)
print("矩阵求逆结果:\n", inv_x)
# 输出:
# tensor([[-2.0000,  1.0000],
#         [ 1.5000, -0.5000]])

注意：矩阵必须是方阵且可逆的，否则会引发错误。

2. 矩阵分解
QR 分解

QR 分解是将一个矩阵分解为一个正交矩阵 Q 和一个上三角矩阵 R。PyTorch 提供了 torch.qr() 函数来进行 QR 分解。

# QR 分解
q, r = torch.qr(x)
print("QR 分解结果 Q:\n", q)
print("QR 分解结果 R:\n", r)
# 输出:
# Q:
# tensor([[-0.3162, -0.9487],
#         [-0.9487,  0.3162]])
# R:
# tensor([[-3.1623, -4.4272],
#         [ 0.0000, -0.6325]])
奇异值分解（SVD）

奇异值分解（SVD）是将一个矩阵分解为三个矩阵 U、S 和 V，使得原矩阵等于 U * S * V^T。PyTorch 提供了 torch.svd() 函数来进行 SVD 分解。

# 奇异值分解（SVD）
u, s, v = torch.svd(x)
print("SVD 分解结果 U:\n", u)
print("SVD 分解结果 S:\n", s)
print("SVD 分解结果 V:\n", v)
# 输出:
# U:
# tensor([[-0.4046, -0.9145],
#         [-0.9145,  0.4046]])
# S:
# tensor([5.4649, 0.3659])
# V:
# tensor([[-0.5760, -0.8174],
#         [ 0.8174, -0.5760]])
3. 求解线性方程组

求解线性方程组是线性代数中的重要应用之一。PyTorch 提供了 torch.solve() 函数来求解线性方程组 Ax = b。

# 定义系数矩阵 A 和右端项向量 b
A = torch.tensor([[3.0, 1.0], [1.0, 2.0]])
b = torch.tensor([[9.0], [8.0]])

# 求解 Ax = b
solution, _ = torch.solve(b, A)
print("线性方程组的解:\n", solution)
# 输出:
# tensor([[2.0000],
#         [3.0000]])

注意：torch.solve() 返回两个值，第一个是解，第二个是LU分解的矩阵。

综合示例

下面是一个综合示例，展示如何进行矩阵运算、矩阵分解和求解线性方程组。

import torch

# 创建一个2x2的矩阵
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.tensor([[5.0, 6.0], [7.0, 8.0]])

# 矩阵乘法
z = torch.matmul(x, y)
print("矩阵乘法结果:\n", z)

# 矩阵求逆
inv_x = torch.inverse(x)
print("矩阵求逆结果:\n", inv_x)

# QR 分解
q, r = torch.qr(x)
print("QR 分解结果 Q:\n", q)
print("QR 分解结果 R:\n", r)

# 奇异值分解（SVD）
u, s, v = torch.svd(x)
print("SVD 分解结果 U:\n", u)
print("SVD 分解结果 S:\n", s)
print("SVD 分解结果 V:\n", v)

# 求解线性方程组 Ax = b
A = torch.tensor([[3.0, 1.0], [1.0, 2.0]])
b = torch.tensor([[9.0], [8.0]])
solution, _ = torch.solve(b, A)
print("线性方程组的解:\n", solution)
总结

通过上述详细的说明和示例，我们展示了如何进行矩阵运算、矩阵分解和求解线性方程组。这些操作在实际应用中非常常见和重要，理解和掌握这些操作能够显著提升你在使用PyTorch进行深度学习和科学计算时的效率和能力。希望这些示例能帮助你更好地理解线性代数的基本操作。

随机数生成

随机数生成在深度学习和科学计算中具有重要作用，例如初始化模型参数、数据增强和蒙特卡洛模拟等。掌握生成均匀分布、正态分布等随机数的方法，以及如何设置随机种子以确保结果可重复性，是非常重要的。下面我们详细介绍这些操作，并提供具体示例。

1. 基本随机数生成
生成均匀分布的随机数

torch.rand 函数用于生成均匀分布的随机数，生成的张量元素在 [0, 1) 区间内。

import torch

# 生成一个 3x3 的张量，元素服从 [0, 1) 均匀分布
x = torch.rand(3, 3)
print("均匀分布的随机数:\n", x)
生成正态分布的随机数

torch.randn 函数用于生成标准正态分布的随机数，均值为 0，标准差为 1。

# 生成一个 3x3 的张量，元素服从标准正态分布
x = torch.randn(3, 3)
print("正态分布的随机数:\n", x)
生成整数随机数

torch.randint 函数用于生成整数随机数，生成的张量元素在 [low, high) 区间内。

# 生成一个 3x3 的张量，元素在 [0, 10) 之间
x = torch.randint(0, 10, (3, 3))
print("整数随机数:\n", x)
其他随机数生成方法

除了上述常见的随机数生成方法，PyTorch 还提供了其他一些方法来生成特定分布的随机数。

生成均值为 mean、标准差为 std 的正态分布随机数
# 生成一个 3x3 的张量，元素服从均值为 2，标准差为 3 的正态分布
x = torch.normal(mean=2, std=3, size=(3, 3))
print("均值为 2，标准差为 3 的正态分布随机数:\n", x)
生成服从 Beta 分布的随机数
# 生成一个 3x3 的张量，元素服从 Beta 分布
x = torch.distributions.Beta(0.5, 0.5).sample((3, 3))
print("Beta 分布的随机数:\n", x)
生成服从泊松分布的随机数
# 生成一个 3x3 的张量，元素服从泊松分布
x = torch.poisson(torch.ones(3, 3) * 5)
print("泊松分布的随机数:\n", x)
2. 设置随机种子

为了确保实验结果的可重复性，通常需要设置随机种子。PyTorch 提供了 torch.manual_seed 函数来设置随机数生成器的种子。

# 设置随机数生成器的种子
torch.manual_seed(42)

# 生成一个 3x3 的张量，元素服从 [0, 1) 均匀分布
x = torch.rand(3, 3)
print("使用随机种子生成的均匀分布随机数:\n", x)

# 再次生成一个 3x3 的张量，元素服从 [0, 1) 均匀分布
# 由于设置了相同的随机种子，生成的结果应当相同
torch.manual_seed(42)
y = torch.rand(3, 3)
print("再次生成的均匀分布随机数:\n", y)
设置 GPU 随机种子

如果你在使用 GPU 进行计算，还需要设置 CUDA 的随机种子，以确保结果的可重复性。

if torch.cuda.is_available():
    torch.cuda.manual_seed(42)
    torch.cuda.manual_seed_all(42)  # 如果有多个GPU
设置 numpy 和 Python 的随机种子

为了确保所有环境下的可重复性，通常还会设置 numpy 和 Python 的随机种子。

import numpy as np
import random

np.random.seed(42)
random.seed(42)
综合示例

下面是一个综合示例，展示如何生成不同分布的随机数以及设置随机种子。

import torch
import numpy as np
import random

# 设置随机种子
torch.manual_seed(42)
np.random.seed(42)
random.seed(42)

if torch.cuda.is_available():
    torch.cuda.manual_seed(42)
    torch.cuda.manual_seed_all(42)

# 生成均匀分布的随机数
x = torch.rand(3, 3)
print("均匀分布的随机数:\n", x)

# 生成正态分布的随机数
x = torch.randn(3, 3)
print("正态分布的随机数:\n", x)

# 生成整数随机数
x = torch.randint(0, 10, (3, 3))
print("整数随机数:\n", x)

# 生成均值为 2，标准差为 3 的正态分布随机数
x = torch.normal(mean=2, std=3, size=(3, 3))
print("均值为 2，标准差为 3 的正态分布随机数:\n", x)

# 生成 Beta 分布的随机数
x = torch.distributions.Beta(0.5, 0.5).sample((3, 3))
print("Beta 分布的随机数:\n", x)

# 生成泊松分布的随机数
x = torch.poisson(torch.ones(3, 3) * 5)
print("泊松分布的随机数:\n", x)
总结

通过上述详细的说明和示例，我们展示了如何生成均匀分布、正态分布等随机数，以及如何设置随机种子以确保结果的可重复性。这些操作在实际应用中非常常见和重要，理解和掌握这些操作能够显著提升你在使用PyTorch进行深度学习和科学计算时的效率和能力。希望这些示例能帮助你更好地理解随机数生成的基本操作。

GPU 加速

GPU 加速是深度学习和科学计算中的一个重要主题。利用 GPU 可以显著提高计算速度，特别是对于大规模数据和复杂模型。下面我们详细介绍 CUDA 的基础知识、如何将张量移动到 GPU 以及如何在 GPU 上进行计算。

1. 张量与设备

在 PyTorch 中，张量可以存储在不同的设备上，例如 CPU 和 GPU。了解如何将张量移动到 GPU 并在 GPU 上进行计算是实现 GPU 加速的关键。

将张量移动到 GPU

你可以使用 to() 方法将张量从 CPU 移动到 GPU。

import torch

# 创建一个在 CPU 上的张量
x = torch.tensor([1.0, 2.0, 3.0])

# 将张量移动到 GPU
if torch.cuda.is_available():
    x = x.to('cuda')
    print("张量已移动到 GPU:", x)
else:
    print("CUDA 不可用，张量仍在 CPU 上:", x)

你也可以在创建张量时直接指定设备。

# 直接在 GPU 上创建张量
if torch.cuda.is_available():
    x = torch.tensor([1.0, 2.0, 3.0], device='cuda')
    print("在 GPU 上创建的张量:", x)
else:
    x = torch.tensor([1.0, 2.0, 3.0])
    print("在 CPU 上创建的张量:", x)
2. 在 GPU 上进行计算
在 GPU 上进行基本运算

在 GPU 上进行计算与在 CPU 上进行计算的方式基本相同，主要区别在于张量所在的设备。

# 确保 CUDA 可用
if torch.cuda.is_available():
    # 在 GPU 上创建两个张量
    x = torch.tensor([1.0, 2.0, 3.0], device='cuda')
    y = torch.tensor([4.0, 5.0, 6.0], device='cuda')

    # 在 GPU 上进行加法运算
    z = x + y
    print("在 GPU 上进行的加法运算结果:", z)
else:
    print("CUDA 不可用，无法在 GPU 上进行运算")
在 GPU 上进行矩阵乘法

矩阵乘法是深度学习中常见的操作，在 GPU 上进行矩阵乘法可以显著提高计算速度。

# 确保 CUDA 可用
if torch.cuda.is_available():
    # 在 GPU 上创建两个矩阵
    a = torch.tensor([[1.0, 2.0], [3.0, 4.0]], device='cuda')
    b = torch.tensor([[5.0, 6.0], [7.0, 8.0]], device='cuda')

    # 在 GPU 上进行矩阵乘法
    c = torch.matmul(a, b)
    print("在 GPU 上进行的矩阵乘法结果:\n", c)
else:
    print("CUDA 不可用，无法在 GPU 上进行运算")
在 GPU 上进行复杂计算

你还可以在 GPU 上进行更复杂的计算，例如神经网络的前向和反向传播。

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(10, 1)
    
    def forward(self, x):
        return self.fc(x)

# 创建神经网络实例并将其移动到 GPU
net = SimpleNet()
if torch.cuda.is_available():
    net.to('cuda')

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 创建训练数据，
input_tensor = torch.randn(100, 10)  # 100个样本，每个样本有10个特征
target = torch.randn(100, 1)         # 100个样本的目标值
#训练的目标就是求解全连接网络的参数，使得input_tensor中的每个值使用self.fc(input_tensor[x])计算出的结构都无限逼近target[x]的值

# 将数据移动到 GPU
if torch.cuda.is_available():
    input_tensor = input_tensor.to('cuda')
    target = target.to('cuda')

# 训练循环
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    output = net(input_tensor)
    
    # 计算损失
    loss = criterion(output, target)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    # 打印每个周期的损失
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 保存训练好的模型权重
torch.save(net.state_dict(), 'simple_net.pth')
print("模型权重已保存")

# 验证训练结果
# 加载模型权重
net.load_state_dict(torch.load('simple_net.pth'))
net.eval()  # 切换到评估模式

# 使用原始数据进行验证
with torch.no_grad():
    # 如果数据在 GPU 上，确保模型也在 GPU 上
    if torch.cuda.is_available():
        input_tensor = input_tensor.to('cuda')
        target = target.to('cuda')
        net.to('cuda')

    # 前向传播
    output = net(input_tensor)
    # 计算损失
    loss = criterion(output, target)
    print(f'验证损失: {loss.item():.4f}')
详细解释

  1. 导入必要的库

    import torch
import torch.nn as nn
import torch.optim as optim

    我们导入了 PyTorch 的核心库 torch 以及用于定义神经网络的 torch.nn 模块和优化器的 torch.optim 模块。

  2. 定义一个简单的神经网络

    class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(10, 1)
    
    def forward(self, x):
        return self.fc(x)

    我们定义了一个简单的神经网络 SimpleNet，它包含一个线性层（全连接层），将输入的 10 个特征映射到 1 个输出。forward 方法定义了前向传播的计算过程。

  3. 创建神经网络实例并将其移动到 GPU

    net = SimpleNet()
if torch.cuda.is_available():
    net.to('cuda')

    我们创建了 SimpleNet 的一个实例 net。如果 CUDA 可用，我们将这个神经网络移动到 GPU 上。

  4. 定义损失函数和优化器

    criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

    我们定义了均方误差损失函数 MSELoss 和随机梯度下降优化器 SGD。优化器的学习率设置为 0.01，并将神经网络的参数传递给优化器。

  5. 创建训练数据并将其移动到 GPU

    input_tensor = torch.randn(100, 10)  # 100个样本，每个样本有10个特征
target = torch.randn(100, 1)         # 100个样本的目标值

if torch.cuda.is_available():
    input_tensor = input_tensor.to('cuda')
    target = target.to('cuda')

    我们创建了形状为 [100, 10] 的随机输入张量 input_tensor 和形状为 [100, 1] 的目标张量 target。如果 CUDA 可用，我们将这些张量移动到 GPU 上。训练的目标就是求解全连接网络的参数，使得input_tensor中的每个值使用self.fc(input_tensor[x])计算出的结构都无限逼近target[x]的值

  6. 训练循环

    num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    output = net(input_tensor)
    
    # 计算损失
    loss = criterion(output, target)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    # 打印每个周期的损失
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

    这里我们设置了训练的周期数 num_epochs 为 1000。每个周期中，我们执行以下步骤：

    • 前向传播：计算模型的输出。
    • 计算损失：使用损失函数计算输出与目标之间的误差。
    • 反向传播和优化：清零梯度，计算梯度，并使用优化器更新模型参数。
    • 打印损失：每10个周期打印一次当前的损失值。

  7. 保存训练好的模型权重

    torch.save(net.state_dict(), 'simple_net.pth')
print("模型权重已保存")

    我们使用 torch.save 函数将训练好的模型权重保存到文件 simple_net.pth 中。

  8. 验证训练结果

    # 加载模型权重
net.load_state_dict(torch.load('simple_net.pth'))
net.eval()  # 切换到评估模式

# 使用原始数据进行验证
with torch.no_grad():
    # 如果数据在 GPU 上，确保模型也在 GPU 上
    if torch.cuda.is_available():
        input_tensor = input_tensor.to('cuda')
        target = target.to('cuda')
        net.to('cuda')

    # 前向传播
    output = net(input_tensor)
    # 计算损失
    loss = criterion(output, target)
    print(f'验证损失: {loss.item():.4f}')

    我们使用 torch.load 函数加载保存的模型权重，并将模型切换到评估模式 eval。然后使用原始训练数据进行前向传播，计算验证损失。通过验证损失，我们可以评估模型的性能。

预期结果

运行该程序时，你将看到每10个周期的训练损失值输出，以及最终的验证损失值。随着训练的进行，损失值应逐渐减小，表示模型在逐步学习和优化。

以下是一个可能的输出示例（注意，随机数生成的结果可能会有所不同）：

Epoch [10/1000], Loss: 1.1005
Epoch [20/1000], Loss: 1.0121
Epoch [30/1000], Loss: 0.9631
...
Epoch [990/1000], Loss: 0.8931
Epoch [1000/1000], Loss: 0.8931
模型权重已保存
验证损失: 0.8931

总结，这个示例展示了如何定义一个简单的神经网络、在 GPU 上进行前向传播、计算损失、执行反向传播和优化步骤，并通过训练循环不断更新模型参数。训练结束后，我们保存模型权重，并使用原始数据进行验证，以评估模型的性能。通过这些步骤，你可以训练一个神经网络模型，并利用 GPU 加速计算。

学习资源

  1. 官方文档

    • PyTorch 官方文档是学习的最佳资源，涵盖了所有张量操作的详细说明和示例代码。
    • PyTorch 官方文档

  2. 在线课程

    • Coursera、edX 和 Udacity 等平台提供了多个 PyTorch 的在线课程。
    • 推荐课程：
      • Coursera 的 “Deep Learning Specialization” by Andrew Ng
      • Udacity 的 “Deep Learning Nanodegree”

  3. 书籍

    • 《Deep Learning with PyTorch》：一本非常全面的 PyTorch 教程书籍，涵盖了基础知识和高级应用。
    • 《Programming PyTorch for Deep Learning》：适合初学者的 PyTorch 入门书籍。

  4. 博客和教程

    • Medium 和 Towards Data Science 上有大量 PyTorch 相关的教程和实践文章。
    • PyTorch 官方博客也定期发布教程和案例研究。

  5. 社区和论坛

    • PyTorch 论坛：一个活跃的社区，用户可以在这里提问、分享经验和交流。
    • Stack Overflow：解决编程问题的好地方，很多 PyTorch 的问题都可以在这里找到答案。

实践与项目

  1. 练习题

    • 在学习过程中，可以通过完成官方文档中的练习题和示例代码来巩固知识。

  2. 小项目

    • 从小项目开始，如实现线性回归、逻辑回归、简单的卷积神经网络等。

  3. 大型项目

    • 当你掌握了基础知识后，可以尝试一些大型项目，如图像分类、自然语言处理、生成对抗网络（GAN）等。

通过以上学习路径和资源，你可以系统地掌握张量及其操作，为进一步学习和应用 PyTorch 打下坚实的基础。

fydw_715
关注
专栏目录
Pytorch中Tensor与各种图像格式的相互转化详解
09-18
PyTorch是目前非常流行的一个深度学习框架，它提供了丰富的API来处理张量（tensor）。在计算机视觉领域，我们经常需要处理图像数据，而图像数据在不同的库中会有不同的表示方式。例如，PIL（Python Imaging Library...
深度学习入门 ---- 张量(Tensor)
小鱼干儿的博客
08-02 9437
Tensor，中文叫张量，是深度学习的一个基础，文章讲解了什么是张量，张量和标量、向量、矩阵之间的关系，张量如何使用，在PyTorch中如如何对张量进行操作 ，
张量tensor——神经网络数据的表示
AnneQiQi的博客
12-17 3690
一般来说，当前所有机器学习系统都使用张量作为基本数据结构。 张量的核心在于，它是一个数据容器。它包含的数据几乎总是数值数据，因此它是数字的容器。如矩阵，它是二维张量。张量是矩阵向任意维度的推广。【注意：张量的维度（dimension）通常叫做轴（axis）】 一、不同维度张量介绍 1.1、标量（0D张量） 仅包含一个数字的张量叫作标量（scalar，也叫标量张量、零维张量、0D 张量）。在...
PyTorch学习系列教程：何为Tensor？
小数志
02-28 8723
导读本文继续PyTorch学习系列教程，来介绍在深度学习中最为基础也最为关键的数据结构——Tensor。一方面，Tensor之于PyTorch就好比是array之于Numpy或者DataF...
张量学习（1）：张量的基本概念
keith的博客
11-20 1万+
1.张量的四种定义 2.张量的表示形式 3.现实世界中的数据张量 4.阶
张量基本概念
CareChere的博客
05-31 1万+
张量是一种表示物理量的方式，这个方式就是用 基向量 与 分量 组合表示物理量（Combinationof basis vector and component）。 由于基向量可以有丰富的组合，张量可以表示非常丰富的物理量。 此外， 张量所描述的物理量是不随观察者或者说参照系而变化的 ，当参照系变化时（其实就是基向量变化），其分量也会相应变化，最后结果就是基向量与分量的组合（也就是张量）保持不变。这一点对于我们 构造数据对象，进而展开分析建模，有着至关重要的意义 。 回顾过去我们对“
详解PyTorch中Tensor的高阶操作
09-18
在PyTorch中，Tensor是核心数据结构，用于表示数值计算和神经网络的权重。本文主要探讨了PyTorch中Tensor的高阶操作，这些操作提供了更高级的数学和逻辑功能，有助于处理复杂的数学问题和神经网络计算。我们将详细...
pytorch::Dataloader中的迭代器和生成器应用详解
09-18
例如，在处理文本数据时，collate_fn可能会将一系列的字符串转换成张量（tensor），同时对它们进行填充或截断以满足固定长度的要求。 总结来说，迭代器和生成器是Python中实现惰性求值和高效内存管理的重要工具，而...
pytorch中tensor的合并与截取方法
12-25
合并： torch.cat(inputs=(a, b), dimension=... 您可能感兴趣的文章:详解PyTorch中Tensor的高阶操作在PyTorch中Tensor的查找和筛选例子PyTorch中Tensor的维度变换实现在pytorch中为Module和Tensor指定GPU的例子pytorc
pytorch cuda上tensor的定义 以及减少cpu的操作详解
09-16
本文将深入探讨如何在PyTorch中定义CUDA上的张量（Tensor）以及如何减少与CPU之间的交互，从而提高计算效率。 首先，让我们了解如何在CUDA上定义张量。在PyTorch中，可以使用`.cuda()`方法将现有的张量转移到GPU上...
什么是张量
欢迎留言技术探讨
03-24 2708
什么是张量 文章搬运于:你真的懂TensorFlow吗？Tensor是神马？为什么还会Flow? 0维张量/标量 标量是一个数字 1维张量/向量 1维张量称为“向量”。 2维张量 2维张量称为矩阵 3维张量 多为矩阵 张量=容器 张量是现代机器学习的基础。它的核心是一个数据容器，多数情况下，它包含数字，有时候它也包含字符串，但这种情况比较少。因此把它想象成一个数字的水桶。 0维张量/标量 装在张量/容器水桶中的每个数字称为“标量”。 标量是一个数字。 你会问为什么不干脆叫它们一个数字呢？ 我不知道
一、张量基础知识
热门推荐
上官永石的博客
07-19 1万+
张量一 1.张量的定义        首先我们来了解一下什么是张量，张量有四个定义： 张量是多维数组 张量是一种不随坐标系的改变而改变的几何对象 张量是向量和余向量，不会随着坐标系的改变而改变 张量是多重线性映射，即 T：V∗×⋯×V∗⏟m×V×⋯×V⏟n→R，V是矢量空间，V∗是对应的对偶空间T：\underbrace{V^* \times \cdots \times V^*}_m \times \underbrace{V
Tensor（张量）
m0_66467467的博客
02-23 1334
pytorch的tensor常见用法
什么是tensor张量？
m0_56175815的博客
03-19 2330
pytorch的tensor的一些基本操作，和实现一个简单线性模型的基本步骤，和很多小细节。
【PyTorch】第一节：张量（Tensor）的定义
荷叶田田的博客
04-12 3311
PyTorch 中的所有操作都是在张量的基础上进行的，本实验主要讲解了张量定义和相关张量操作以及 GPU 和张量之间的关系，为以后使用 PyTorch 进行深度学习打下坚实的基础。
PyTorch框架学习（一） — Tensor（张量）详解
Roar冷颜的博客
11-19 7498
PyTorch框架学习 — Tensor（张量）详解
什么是张量(tensor)？&计算机视觉&深度学习
最新发布
举个栗子的博客
03-09 2581
在数学中，张量是一种用于描述多维空间中的线性关系的对象。它可以看作是向量和矩阵的推广。标量是0阶张量，向量是1阶张量，矩阵是2阶张量，更高阶的数组则称为高阶张量。在计算机视觉中，张量通常用于表示图像数据。例如，一个彩色图像可以表示为一个3阶张量，其维度为（高度，宽度，颜色通道）。这种表示方法使得对图像进行操作和处理变得更加方便和高效。张量是连接数学、人工智能和计算机视觉的重要纽带。它们在表示和处理多维数据方面发挥着关键作用。
如何理解pytorch中的张量
06-08
在 PyTorch 中，张量（Tensor）是一种类似于数组的数据结构，可以在 CPU 或 GPU 上存储和操作多维数组。 与 NumPy 数组一样，PyTorch 张量也具有以下特点： 1. 张量是多维数组，可以在 0 至 N 维之间选择。 2. 张量中的元素数据类型必须相同。 3. 张量支持广播（Broadcasting）和向量化操作（Vectorized Operations），使得数学运算变得高效并且易于表达。 4. 张量可以在 CPU 或 GPU 上进行计算。 与 NumPy 数组不同的是，PyTorch 张量具有以下特点： 1. PyTorch 张量支持自动求导（Autograd），可以方便地进行梯度计算。 2. PyTorch 张量可以使用 CUDA 进行加速计算，从而实现更快的运算速度。 在深度学习中，张量是一种非常重要的数据结构，可以表示输入数据、模型参数、输出结果等。PyTorch 提供了丰富的张量操作函数，可以方便地进行数值计算和深度学习模型的实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值