深度学习:PyTorch张量基本运算、形状改变、索引操作、升维降维、维度转置、张量拼接

本文目录:

一、张量数值运算

(一)基本运算

+、-、*、/、add、sub、mul、div、neg

复制代码
例:
data = torch.randint(0, 10, [2, 3])
print(data)
# 1. 不修改原数据
new_data = data.add(10)  # 等价 new_data = data + 10
print(new_data)
# 2. 直接修改原数据 注意: 带下划线的函数为修改原数据本身
data.add_(10)  # 等价 data += 10
print(data)
# 3. 其他函数
print(data.sub(100))
print(data.mul(100))
print(data.div(100))
print(data.neg())   #对元素取负

(二)点乘运算

点乘(Hadamard)为元素间相乘,指的是相同形状的张量对应位置的元素相乘,使用mul和运算符 * 实现。

复制代码
例:
data1 = torch.tensor([[1, 2], [3, 4]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 第一种方式
data = torch.mul(data1, data2)
print(data)
# 第二种方式
data = data1 * data2
print(data)

(三)矩阵乘法

要求第一个矩阵 shape: (n, m),第二个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。运算符包括@、matmul(要求至少2维向量;对最后两个维度进行矩阵乘法,其他维度【如果有】按广播规则处理。)、dot(仅针对1维张量)

复制代码
例:
# 点积运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 方式一:
data3 = data1 @ data2
print("data3-->", data3)
# 方式二:
data4 = torch.matmul(data1, data2)
print("data4-->", data4)

扩展:广播规则

NumPy、PyTorch、TensorFlow 等科学计算库中的一种重要机制,用于自动扩展不同形状的张量(或数组),使它们能够按元素进行运算(如加减乘除、矩阵乘法等)。它的核心目的是简化代码,避免显式复制数据,同时保持计算效率。

复制代码
例:
import numpy as np

a = np.array([1, 2, 3])  # shape (3,)
b = 2                    # shape () (标量)
c = a + b                # 广播:b 被扩展为 [2, 2, 2]
print(c)                 # 输出: [3 4 5]

a = np.array([[1], [2], [3]])  # shape (3, 1)
b = np.array([10, 20])         # shape (2,)
c = a + b                      # 广播步骤:
                               # 1. a 扩展为 (3, 2): [[1, 1], [2, 2], [3, 3]]
                               # 2. b 扩展为 (3, 2): [[10, 20], [10, 20], [10, 20]]
print(c)
# 输出:
# [[11 21]
#  [12 22]
#  [13 23]]

a = np.random.rand(2, 1, 3)  # shape (2, 1, 3)
b = np.random.rand(4, 3)     # shape (4, 3)
c = a + b                    # 广播步骤:
                             # 1. a 扩展为 (2, 4, 3)
                             # 2. b 扩展为 (2, 4, 3)
print(c.shape)               # 输出: (2, 4, 3)

二、运算函数

min、sum、max、pow。。。。。。

dim=0:按列计算;dim=1:按行计算。

复制代码
例:
import torch

data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
print(data)
# 1. 计算均值
# 注意: tensor 必须为 Float 或者 Double 类型
print(data.mean())
print(data.mean(dim=0))  # 按列计算均值
print(data.mean(dim=1))  # 按行计算均值
# 2. 计算总和
print(data.sum())
print(data.sum(dim=0))
print(data.sum(dim=1))
# 3. 计算平方
print(torch.pow(data,2))
# 4. 计算平方根
print(data.sqrt())
# 5. 指数计算, e^n 次方
print(data.exp())
# 6. 对数计算
print(data.log())  # 以 e 为底
print(data.log2())
print(data.log10())

三、索引操作:类似于loc[ ]、iloc[ ]

复制代码
例:
import torch


# 随机生成数据
data = torch.randint(0, 10, [4, 5])
print(data)

# 1.简单行、列索引
print(data[0])
print(data[:, 0])

# 2.列表索引
# 返回 (0, 1)、(1, 2) 两个位置的元素
print(data[[0, 1], [1, 2]])
# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])


# 3.范围索引
# 前3行的前2列数据
print(data[:3, :2])
# 第2行到最后的前2列数据
print(data[2:, :2])

# 4.布尔索引
# 第三列大于5的行数据
print(data[data[:, 2] > 5])
# 第二行大于5的列数据
print(data[:, data[1] > 5])

# 5.多维索引
# 随机生成三维数据
data = torch.randint(0, 10, [3, 4, 5])
print(data)
# 获取0轴上的第一个数据
print(data[0, :, :])
# 获取1轴上的第一个数据
print(data[:, 0, :])
# 获取2轴上的第一个数据
print(data[:, :, 0])

四、形状操作

(一)reshape

保证数据不变的情况下改变形状,可处理连续变量也可处理非连续变量;

复制代码
例:
import torch

data = torch.tensor([[10, 20, 30], [40, 50, 60]])
# 1. 使用 shape 属性或者 size 方法都可以获得张量的形状
print(data.shape, data.shape[0], data.shape[1])
print(data.size(), data.size(0), data.size(1))

# 2. 使用 reshape 函数修改张量形状
new_data = data.reshape(1, 6)
print(new_data.shape)

(二)view

只可处理连续变量,处理前可用is_contiguous作连续性判断。另外,当张量的底层数据在内存中的存储顺序与其逻辑顺序不一致,view函数无法对这样的张量进行变形处理,例如: 一个张量经过了 transpose 或者 permute 函数的处理之后,就无法使用 view 函数进行形状操作。

复制代码
例:
# 1 一个张量经过了 transpose 或者 permute 函数的处理之后,就无法使用 view 函数进行形状操作; 若要使用view函数, 需要使用contiguous() 变成连续以后再使用view函数。
# 2 判断张量是否连续
data = torch.tensor([[10, 20, 30],[40, 50, 60]])
print('data--->', data, data.shape)
# 1 判断张量是否连续
print(data.is_contiguous()) # True
# 2 view
mydata2 = data.view(3, 2)
print('mydata2--->', mydata2, mydata2.shape)
# 3 判断张量是否连续
print('mydata2.is_contiguous()--->', mydata2.is_contiguous())
# 4 使用 transpose 函数修改形状
mydata3 = torch.transpose(data, 0, 1)  
print('mydata3--->', mydata3, mydata3.shape)
print('mydata3.is_contiguous()--->', mydata3.is_contiguous())
# 5 需要先使用 contiguous 函数转换为连续的张量,再使用 view 函数
print (mydata3.contiguous().is_contiguous())
mydata4 = mydata3.contiguous().view(2, 3)
print('mydata4--->', mydata4.shape, mydata4)

五、squeeze与unsqueeze

squeeze:删除指定位置形状为1的维度,不指定位置删除所有形状为1的维度,降维;> unsqueeze:在指定位置添加形状为1的维度,升维

注意:reshape、切片、view也可通过改变形状变相实现升维降维功能,但不是标准用法。

复制代码
例:
mydata1 = torch.tensor([1, 2, 3, 4, 5])             
print('mydata1--->', mydata1.shape, mydata1) # 一个普通的数组 1维数据
mydata2 = mydata1.unsqueeze(dim=0)
print('在0维度上 拓展维度:', mydata2, mydata2.shape)  # 1*5
mydata3 = mydata1.unsqueeze(dim=1)
print('在1维度上 拓展维度:', mydata3, mydata3.shape)  # 5*1
mydata4 = mydata1.unsqueeze(dim=-1)
print('在-1维度上 拓展维度:', mydata4, mydata4.shape) # 5*1
mydata5 = mydata4.squeeze()
print('压缩维度:', mydata5, mydata5.shape)  # 1*5

六、transpose和permute

transpose:实现交换张量形状的指定维度, 例如: 一个张量的形状为 (2, 3, 4) ,把 3 和 4 进行交换, 将张量的形状变为 (2, 4, 3) ;

permute:一次交换更多的维度。

复制代码
例:
data = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
print('data shape:', data.size())
# 1. 交换1和2维度
mydata2 = torch.transpose(data, 1, 2)
print('mydata2.shape--->', mydata2.shape)
# 2. 将data 的形状修改为 (4, 5, 3), 需要变换多次
mydata3 =  torch.transpose(data, 0, 1)
mydata4 = torch.transpose(mydata3, 1, 2)
print('mydata4.shape--->', mydata4.shape)
# 3. 使用 permute 函数将形状修改为 (4, 5, 3)
# 3-1 方法1
mydata5 = torch.permute(data, [1, 2, 0])
print('mydata5.shape--->', mydata5.shape)
# 3-2 方法2
mydata6 = data.permute([1, 2, 0])
print('mydata6.shape--->', mydata6.shape)

七、张量拼接操作

(一)cat/concat

复制代码
        沿着现有维度连接一系列张量。
      所有输入张量除了指定的拼接维度外,其他维度必须匹配,即指定拼接维度可不一样,其它维度必须一样。

例:
import torch

data1 = torch.randint(0, 10, [1, 2, 3])
data2 = torch.randint(0, 10, [1, 2, 3])
print(data1)
print(data2)
# 1. 按0维度拼接
new_data = torch.cat([data1, data2], dim=0)
print(new_data)
print(new_data.shape)
# 2. 按1维度拼接
new_data = torch.cat([data1, data2], dim=1)
print(new_data)
print(new_data.shape)
# 3. 按2维度拼接
new_data = torch.cat([data1, data2], dim=2)
print(new_data)
print(new_data.shape)

(二)stack

在一个新的维度上连接一系列张量,这会增加一个新维度;所有输入张量的形状必须完全相同。

二维张量(比如(2,3))之所以在stack上有0、1、2三个维度拼接方式,是因为stack可以在末尾创造一个新维度。

stack关于二维张量的拼接操作:

复制代码
例:
import torch
data1 = torch.randint(0, 10, [2, 3])
data2 = torch.randint(0, 10, [2, 3])
print(data1)
print(data2)
# 1. 在0维度上拼接
new_data = torch.stack([data1, data2], dim=0)
print(new_data)
print(new_data.shape)
# 2. 在1维度上拼接
new_data = torch.stack([data1, data2], dim=1)
print(new_data)
print(new_data.shape)
# 3. 在2维度上拼接
new_data = torch.stack([data1, data2], dim=2)
print(new_data)
print(new_data.shape)

今天的分享到此结束。

相关推荐
Ai墨芯1116 分钟前
靠机器学习+组合优化就发了CCF-A
人工智能
Morpheon8 分钟前
揭开预训练Pre-Training的力量:革新机器学习
人工智能·机器学习
勤奋的大熊猫8 分钟前
机器学习中的 Agent 是什么?
人工智能·机器学习·agent
Blossom.1189 分钟前
机器学习在智能建筑中的应用:能源管理与环境优化
人工智能·python·深度学习·神经网络·机器学习·机器人·sklearn
明朝百晓生12 分钟前
深入理解Vapnik-Chervonenkis(VC)维度:机器学习泛化能力的理论基础
人工智能·机器学习
信息快讯12 分钟前
机器学习驱动的智能化电池管理技术与应用
人工智能·机器学习·锂离子电池
勤奋的大熊猫13 分钟前
机器学习路径规划中的 net 和 netlist 分别是什么?
人工智能·机器学习·自动寻路
还有糕手14 分钟前
西南交通大学【机器学习实验6】
人工智能·机器学习
静心问道44 分钟前
self-consistency:自洽性提升语言模型中的链式思维推理能力
人工智能·语言模型·大模型
上海锝秉工控1 小时前
防爆拉线位移传感器:工业安全的“隐形守护者”
大数据·人工智能·安全