从原理到实践 | Pytorch tensor 张量花式操作

Qodi2023-09-19 15:08

文章目录

  • 1.张量形状与维度
  • [2. 张量其他创建方式](#2. 张量其他创建方式)
    • [2.1 创建全零或全一张量：](#2.1 创建全零或全一张量：)
    • [2.2 创建随机张量：](#2.2 创建随机张量：)
    • [2.3 创建单位矩阵：](#2.3 创建单位矩阵：)
    • [2.4 创建序列张量：](#2.4 创建序列张量：)
  • [3. 张量元素](#3. 张量元素)
    • [3.1 查看元素类型](#3.1 查看元素类型)
    • [3.2 张量元素类型转换](#3.2 张量元素类型转换)
  • [4. 张量运算](#4. 张量运算)
    • [4.1 张量的基本运算](#4.1 张量的基本运算)
    • [p.2 张量间乘法点积运算](#p.2 张量间乘法点积运算)
    • [4.3 张量元素运算函数](#4.3 张量元素运算函数)
  • [5.张量的拼接 切片 扩展 重塑 改变形状等操作](#5.张量的拼接 切片 扩展 重塑 改变形状等操作)
    • [5.1 张量拼接（Concatenation）：](#5.1 张量拼接（Concatenation）：)
    • [5.2 张量切片（Slicing）：](#5.2 张量切片（Slicing）：)
    • [5.3 张量转置（Transpose）：](#5.3 张量转置（Transpose）：)
    • [5.4 张量形状重塑：](#5.4 张量形状重塑：)
  • 6.广播机制
    • [6.1 张量+标量](#6.1 张量+标量)
    • [6.2 张量+张量](#6.2 张量+张量)

Tensor（张量）是一种多维数组（通常是数字）数据类型，是深度学习和机器学习中最基本的数据结构之一。

PyTorch提供了一种直观的方式来创建和操作张量，而且它还支持GPU加速，这对于深度学习任务非常重要。我们可以使用PyTorch来定义神经网络模型、进行前向传播和反向传播，以及许多其他深度学习任务，因而了解张量是了解这些任务的基础。

1.张量形状与维度

维度（Rank）：张量的维度也称为秩（rank），表示张量中轴（或维度）的数量。标量是0维张量，向量是1维张量，矩阵是2维张量，以此类推。

我们使用**.shape** 查看形状，.ndim属性查看维度

当使用PyTorch库时，我们可以轻松地创建和操作张量。下面是使用PyTorch创建不同秩的张量的示例代码：

1.1标量（0维张量）：

python 复制代码 
import torch

scalar = torch.tensor(5)  # 创建一个标量
print("Scalar:", scalar)
print("Scalar的秩（Rank）:", scalar.ndim)  # 输出0，表示秩为0
print("Scalar的形状", scalar.shape) #输出torch.Size([])  #输出torch.Size([])此时形状向量输出为空

1.2 向量（1维张量）：

import torch

vector = torch.tensor([1, 2, 3, 4])  # 创建一个向量
print("Vector:", vector)
print("Vector的秩（Rank）:", vector.ndim ) # 输出1，表示秩为1
print("vector的形状", vector.shape) #输出torch.Size([4])

1.3矩阵（2维张量）：

python 复制代码 
import torch

matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 创建一个2x3的矩阵
print("Matrix:")
print(matrix)
print("Matrix的秩（Rank）:", matrix.ndim  # 输出2，表示秩为2
print("Matrix的形状:", matrix.shape  # 输出torch.Size([2,3]) 2x3的矩阵

1.4高维张量：

python 复制代码 
import torch
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # 创建一个2x2x2的3维张量
print("3D Tensor:")
print(tensor_3d)
print("3D Tensor的秩（Rank）:", tensor_3d.ndim)  # 输出3，表示秩为3
print("3D Tensor的形状:", tensor_3d.shape ) # 输出torch.Size([2,2,2]) 2x2x2的3维张量

2. 张量其他创建方式

以上我们实际上是通过torch.tensor函数把列表转换为tensor张量

除此之外，还有一些其他torch内置函数的创建方式

2.1 创建全零或全一张量：

python 复制代码 
# 创建特定形状的全零张量
zeros_tensor = torch.zeros(3, 2) #创建形状(3,2)的全零张量

# 创建特定形状的全一张量
ones_tensor = torch.ones(2, 3)#创建形状(2,3)的全一张量

2.2 创建随机张量：

python 复制代码 
# 创建特定形状的随机均匀分布的张量 每个元素都会随机生成，取值范围是大于等于0且小于1的浮点数。
uniform_random = torch.rand(2, 2) #形状(2,2)

# 创建随机正态分布的张量
normal_random = torch.randn(3, 3)  #形状(3,3)

2.3 创建单位矩阵：

python 复制代码 
# 创建单位矩阵
identity_matrix = torch.eye(4)

输出

tensor([[1., 0., 0., 0.],

[0., 1., 0., 0.],

[0., 0., 1., 0.],

[0., 0., 0., 1.]])

2.4 创建序列张量：

python 复制代码 
# 创建从0到4的张量
sequence_tensor = torch.arange(5)

# 创建从2到10的张量，步长为2
sequence_with_step = torch.arange(2, 11, step=2)

3. 张量元素

张量中的每个值称为元素。根据张量的维度和形状，可以有不同数量的元素。例如，一个形状为(3, 4)的张量将包含12个元素。

每个元素可以有不同的类型

张量可以包含不同的数据类型，如整数、浮点数、布尔值等。常见的数据类型包括int32、float32、bool等

3.1 查看元素类型

使用 .dtype 属性可以查看张量的数据类型。例如：

python 复制代码 
pythonCopy codeimport torch

# 创建一个张量
tensor = torch.tensor([1, 2, 3, 4], dtype=torch.float32)

# 查看张量的数据类型
print(tensor.dtype)

输出将显示张量的数据类型，例如 torch.float32

注意，python其他数据类型查看是通过type函数()，注意区分，距离如下

python 复制代码 
# 定义不同类型的变量
integer_variable = 42
float_variable = 3.14
string_variable = "Hello, World!"
list_variable = [1, 2, 3]
dictionary_variable = {"name": "John", "age": 30}

# 使用 type() 函数查看数据类型
print(type(integer_variable))  # <class 'int'>
print(type(float_variable))    # <class 'float'>
print(type(string_variable))   # <class 'str'>
print(type(list_variable))     # <class 'list'>
print(type(dictionary_variable))  # <class 'dict'>

3.2 张量元素类型转换

通过to函数() 或者用type()函数

注意这里的type（）函数是tensor张量自己带的，不是上面讲到3.1讲到的python内的type函数

python 复制代码 
import torch
# 创建一个整数类型的张量
int_tensor = torch.tensor([1, 2, 3, 4],dtype=torch.int32)

# 将整数类型的张量转换为浮点数类型  或者 float_tensor = int_tensor.type(torch.float32)
float_tensor = int_tensor.to(torch.float32)


# 查看新的张量的数据类型
print(float_tensor.dtype)

输出为 torch.float32

注意 执行to函数之后必须进行赋值操作，否则该操作就丢失了，查看下面的代码

python 复制代码 
import torch
# 创建一个整数类型的张量
int_tensor = torch.tensor([1, 2, 3, 4],dtype=torch.int32)
# 将整数类型的张量转换为浮点数类型
int_tensor.to(torch.float32)
# 查看新的张量的数据类型
print(int_tensor.dtype)

最开始我觉得会输出torch.float32 实际输出torch.int32

4. 张量运算

4.1 张量的基本运算

  • 加法和减法 ：可以使用 + 和 - 运算符执行张量的逐元素加法和减法。
  • 乘法和除法 ：可以使用 * 和 / 运算符执行逐元素的乘法和除法。
  • 幂运算 ：使用 ** 运算符进行幂运算。
  • 取负值 ：使用 - 运算符取张量的负值。
python 复制代码 
import torch

# 创建两个示例张量
tensor1 = torch.tensor([1.0, 2.0, 3.0])
tensor2 = torch.tensor([4.0, 5.0, 6.0])

# 加法和减法
result_addition = tensor1 + tensor2  # 逐元素加法
result_subtraction = tensor1 - tensor2  # 逐元素减法

# 乘法和除法
result_multiplication = tensor1 * tensor2  # 逐元素乘法
result_division = tensor1 / tensor2  # 逐元素除法

# 幂运算
exponent = 2
result_power = tensor1 ** exponent  # 每个元素求平方

# 取负值
result_negation = -tensor1  # 每个元素取负值

print("Addition:", result_addition)
print("Subtraction:", result_subtraction)
print("Multiplication:", result_multiplication)
print("Division:", result_division)
print("Power:", result_power)
print("Negation:", result_negation)

输出

p.2 张量间乘法点积运算

  1. 矩阵相乘：

    使用 torch.matmul() 函数或 @ 运算符 或**torch.mm()** 可以执行两个张量（矩阵）的矩阵相乘。矩阵相乘要求左边矩阵的列数等于右边矩阵的行数。

    python 复制代码 
    import torch

# 创建两个示例矩阵
matrix1 = torch.tensor([[1, 2], [3, 4]])
matrix2 = torch.tensor([[5, 6], [7, 8]])

# 矩阵相乘 matmul
result_matrix_mul_1 = torch.matmul(matrix1, matrix2)
# 或者使用 @ 运算符
result_matrix_mul_2 = matrix1 @ matrix2
# 矩阵相乘 mm
result_matrix_mul_3=torch.mm(matrix1, matrix2)

print("Matrix Multiplication:")
print(result_matrix_mul_1)
print(result_matrix_mul_2)
print(result_matrix_mul_3)

    输出将是两个矩阵相乘的结果

    Matrix Multiplication:

    tensor([[19, 22],

    [43, 50]])

    tensor([[19, 22],

    [43, 50]])

    tensor([[19, 22],

    [43, 50]])

  2. 批量矩阵相乘：

    使用 torch.matmul() 函数和**@运算符可以执行两个张量的批量矩阵相乘。这对于同时处理多个矩阵非常有用，但要求最后两个维度必须是矩阵的维度**。而mm只能用于单个矩阵乘法

    python 复制代码 
    import torch

# 创建两个批量矩阵（3个2x2矩阵）
batch_matrix1 = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
batch_matrix2 = torch.tensor([[[2, 0], [1, 2]], [[-1, -2], [-3, -4]], [[0, 1], [-1, 0]]])

# 执行批量矩阵相乘
result_batch_matrix_mul_1 = batch_matrix1 @ batch_matrix2
result_batch_matrix_mul_2 =torch.matmul(batch_matrix1,batch_matrix2)
# 或者使用 @ 运算符
# result_batch_matrix_mul = batch_matrix1 @ batch_matrix2

print("Batch Matrix Multiplication:")
print(result_batch_matrix_mul_1)
print(result_batch_matrix_mul_2)

    输出将是批量矩阵相乘的结果

    输出

    Batch Matrix Multiplication:

    tensor([[[ 4, 4],

    [ 10, 8]],

    ​ [[-23, -34],

    ​ [-31, -46]],

       	 [[-10,   9],
		 [-12,  11]]])

    tensor([[[ 4, 4],

    [ 10, 8]],

         [[-23, -34],
		 [-31, -46]],

    ​ [[-10, 9],

    ​ [-12, 11]]])

  3. 点积：

    点积是两个向量的内积，也可以视为两个矩阵的逐元素乘法后的和。在 PyTorch 中，可以使用 torch.dot() 函数来计算两个一维张量的点积。

    python 复制代码 
    import torch

# 创建两个一维示例张量
vector1 = torch.tensor([1, 2, 3])
vector2 = torch.tensor([4, 5, 6])

# 计算点积
dot_product = torch.dot(vector1, vector2)

print("Dot Product:")
print(dot_product)

    输出将是两个向量的点积结果

Dot Product:

tensor(32)

4.3 张量元素运算函数

tensor张量还会自带很多的运算函数，方便我们的操作

4.3.1逐元素运算函数：

这些运算将分别应用于张量的每个元素，结果将生成一个与原始张量相同形状的新张量。

  • torch.abs(tensor)：计算张量中每个元素的绝对值。
  • torch.sqrt(tensor)：计算张量中每个元素的平方根。
  • torch.exp(tensor)：计算张量中每个元素的指数值。
  • torch.log(tensor)：计算张量中每个元素的自然对数。

4.3.2 统计汇总运算函数

这些运算将返回张量的单个标量值，通常用于统计和汇总。

  • torch.sum(tensor)：计算张量中所有元素的和。
  • torch.mean(tensor)：计算张量中所有元素的平均值。
  • torch.max(tensor) 和 torch.min(tensor)：计算张量中的最大值和最小值。
  • torch.argmax(tensor) 和 torch.argmin(tensor)：返回张量中最大值和最小值的索引。
  • torch.unique(tensor)：返回张量中的唯一元素。
  • torch.histc(tensor, bins=10, min=0, max=1)：计算张量的直方图。

5.张量的拼接 切片 扩展 重塑 改变形状等操作

PyTorch 提供了一系列用于处理和操作张量的运算，包括拼接、切片、转置、扩展和重塑等。以下是这些运算的详细介绍：

5.1 张量拼接（Concatenation）：

  • torch.cat(tensors, dim=0)：将多个张量沿指定维度 dim 进行拼接，生成一个新的张量。这在将多个张量连接在一起时非常有用。

    python 复制代码 
    import torch

# 创建两个示例张量
tensor1 = torch.tensor([[1, 2,3], [4, 5,6]])  #（2×3）
tensor2 = torch.tensor([[7, 8,9], [10, 11,12]]) #（2×3）

# 沿行维度进行拼接
result_concatenation_row = torch.cat((tensor1, tensor2), dim=0) #行维度对应相加，最后拼接后的形状(4×3)
result_concatenation_column=torch.cat((tensor1, tensor2), dim=1)#列维度对应相加，最后拼接后的形状(2×6)

print("Concatenation:")
print(result_concatenation_row)
print(result_concatenation_column)

Concatenation:

tensor([[ 1, 2, 3],

[ 4, 5, 6],

[ 7, 8, 9],

[10, 11, 12]])

tensor([[ 1, 2, 3, 7, 8, 9],

[ 4, 5, 6, 10, 11, 12]])

5.2 张量切片（Slicing）：

  • 使用索引和切片运算符 [] 对张量进行切片。可以指定要提取的元素的索引或范围。这对于获取部分数据非常有用。

    python 复制代码 
    import torch

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

# 提取特定元素
element = tensor[0, 1]  # 获取第一行第二列的元素

# 提取特定行或列
row = tensor[1, :]  # 获取第二行的所有元素
column = tensor[:, 2]  # 获取第三列的所有元素

print("Element:", element)
print("Row:", row)
print("Column:", column)

Element: tensor(2)

Row: tensor([4, 5, 6])

Column: tensor([3, 6, 9])

5.3 张量转置（Transpose）：

  • torch.transpose(tensor, dim0, dim1)：将张量的指定维度进行转置，生成一个新的张量。这对于调整张量的维度顺序非常有用。

    python 复制代码 
    import torch

# 创建一个示例张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 转置张量
transposed_tensor = torch.transpose(tensor, dim0=0, dim1=1)  # 交换行和列

print("Transposed Tensor:")
print(transposed_tensor)

输出

Transposed Tensor:

tensor([[1, 4],

[2, 5],

[3, 6]])

5.4 张量形状重塑：

  • tensor.view(new_shape)或者函数tensor.reshape(new_shape)将张量的形状重塑为新的形状，生成一个新的张量。这对于改变张量的形状非常有用，但要确保新形状与原始形状兼容。

    python 复制代码 
    pythonCopy codeimport torch

# 创建一个示例张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 重塑张量的形状
reshaped_tensor = tensor.view(3, 2)  # 将2x3矩阵重塑为3x2矩阵

print("Reshaped Tensor:")
print(reshaped_tensor)

这些张量操作非常有用，可用于处理和操作 PyTorch 张量，适应不同的任务和需求。请根据您的具体情况选择适当的操作。

6.广播机制

广播（Broadcasting）是一种在 PyTorch 中执行元素级运算的机制，它允许在不同形状的张量之间进行运算，而无需显式地扩展（重复复制）其中一个张量。广播使得在不同形状的张量上执行操作更加方便，因为它自动调整张量的形状，以使其兼容。

6.1 张量+标量

python 复制代码 
import torch

# 创建示例张量
tensor = torch.tensor([[1, 2], [3, 4]])

# 使用广播将标量加到矩阵的每个元素上
scalar = 2
result_broadcasting = tensor + scalar

print("Broadcasting:")
print(result_broadcasting)

输出

Broadcasting:

tensor([[3, 4],

[5, 6]])

6.2 张量+张量

广播规则如下：

不要求两个张量维度数相等，但要求从右向左逐一比较张量的维度（直到维度低的向量比较完毕）满足以下两个条件之一即可

(1)两个张量该维度相等

(2)其中一个张量该维度是1

如果在某一维度的比较上两者都不满足，则会引发广播错误。

python 复制代码 
tensor_1=torch.ones(2,3,4)  #2*3*4

tensor_2=torch.ones(3,1)    #3*1

tensor=tensor_2+tensor_1
print(tensor)

如上，从右向左 ，第一维（4和1 ）虽然不相等，但tensor_2为1 满足条件（2）

​ 继续从右向左，第二维(3,3 )相等，满足条件（1）

​ 此时低维向量比较完毕，所以上述两者可以广播

python 复制代码 
tensor_1=torch.ones(2,3,3)#2*3*2

tensor_2=torch.ones(2,1)  #2*3

tensor=tensor_2+tensor_1
print(tensor)

而这个例子，从右向左 ，第一维（3和1 ）虽然不相等，但tensor_2为1 满足条件（2）

​ 继续从右向左，第二维(3,2 )不相等，不满足条件（1），也不满足条件（2），引发广播失败

相关推荐
qq_2739002315 分钟前
pytorch detach方法介绍
人工智能·pytorch·python
AI狂热爱好者32 分钟前
A3超级计算机虚拟机，为大型语言模型LLM和AIGC提供强大算力支持
服务器·人工智能·ai·gpu算力
边缘计算社区32 分钟前
推理计算：GPT-o1 和 AI 治理
人工智能·gpt
OBOO鸥柏1 小时前
OBOO鸥柏“触摸屏广告一体机交互”亮相2024中国珠海航展
大数据·人工智能·科技·交互
声网1 小时前
DeepL Voice：会议、对话实时语音翻译工具；吴佳俊团队：场景语言，智能补全文本到 3D 的场景理解
人工智能
Geeksend邮件营销1 小时前
定时清理潜在客户列表中的无效邮箱可提高EDM电子邮件自动化营销邮件送达率
人工智能·产品运营·用户运营·内容运营
新加坡内哥谈技术1 小时前
提升AI性能的关键大型语言模型（LLM）压缩策略
人工智能·语言模型·自然语言处理
OCR_wintone4211 小时前
易泊车牌识别相机：4S 店的智能之选
人工智能·数码相机·ocr
棱角~~2 小时前
10款音频剪辑工具的个人实践体验感受！！
人工智能·经验分享·其他·音视频·学习方法
铭瑾熙2 小时前
深度学习之GAN的生成能力评价
人工智能·深度学习·生成对抗网络
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10智能车联网安全发展形势、挑战