tensor 的计算操作

1、创建tensor

  常见创建 tensor 的方法

函数	作用
torch.Tensor(*size)	通过指定尺寸，生成一个 值全为 0 的 tensor
torch.tensor(*list)	直接通过指定数据，生成tensor，支持 List、Numpy数组
torch.eye(row, column)	按照指定的行列数，生成二维单位tensor
torch.rand(*size)	从 (0, 1) 之间，进行均匀分布采样，生成指定size 的tensor
torch.randn(*size)	从标准正态分布中采样，生成指定size 的tensor
torch.ones(*size)	按照指定 size，生成 值全为1 的 tensor
torch.zeros(*size)	按照指定 size，生成 值全为0 的 tensor
torch.ones_like(t)	返回尺寸与 t 相同的，值全为1 的 tensor
torch.zeros_like(t)	返回尺寸与 t 相同的，值全为0 的 tensor
torch.arange(start, end, step)	在区间[start, end) 上，每间隔 step 生成一个序列张量
torch.linspace(start, end, steps)	从 start 到 end，均匀切分成 steps 份
torch.from_Numpy(ndarray)	根据 ndarray 生成 tensor

  你可以将如下生成的 tensor，逐个打印，进行观察

import numpy as np
import torcha = torch.Tensor(2, 3)
b = torch.tensor([[1, 2, 3], [4, 5, 6]])c = torch.eye(3, 3)d = torch.rand(2, 3)
e = torch.randn(2, 3)f = torch.ones(3, 2)
g = torch.zeros(2, 3)
h = torch.ones_like(b)
i = torch.zeros_like(b)j = torch.linspace(1, 10, 4)
k = torch.arange(1, 5, 2)l = np.arange(1, 5)
m = torch.from_numpy(l)

---

2、查看 tensor 的形状

函数	作用
tensor.numel()	统计 tensor 元素的个数
tensor.size()	获取 tensor的尺寸，tensor.size() 是一个方法
tensor.shape	获取 tensor的尺寸，tensor.shape 是一个属性

import torcha = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(a.numel())
print(a.size())
print(a.shape)

 

---

3、修改 tensor 形状

函数	作用
tensor.view(*size)	修改 tensor 的尺寸，返回的对象 与 源tensor 共享内存（修改一个，另一个也会被修改）
tensor.resize(*size)	修改 tensor 的尺寸，类似于view，但在size 超出时会重新分配内存空间
tensor.reshape(*size)	修改 tensor 的尺寸，返回的对象是一个新生成的tensor，且不要求源tensor 是连续的
tensor.flatten()	将张量扁平化为一维张量
torch.unsqueeze(dim)	在指定维度增加一个 “1”
torch.squeeze(dim)	在指定维度删除一个 “1”
tensor.transpose(dim0, dim1)	交换 dim0 和 dim1 指定的两个维度，返回一个新的张量而不修改原始张量
tensor.permute(dims)	按照 dims 指定的顺序重新排列张量的维度，返回一个新的张量而不修改原始张量

import torcha = torch.tensor([[1, 2, 3], [4, 5, 6]])print(a.view(3, 2))
print(a.resize(3, 2))
print(a.reshape(3, 2))
print(a.flatten())

import torcha = torch.tensor([[[1, 2, 3], [4, 5, 6]]])
print(a.shape)b = torch.unsqueeze(a, 0)
print(b.shape)c = torch.squeeze(b, 0)
print(c.shape)

 

import torcha = torch.tensor([[1, 2, 3], [4, 5, 6]])
b = a.transpose(dim0=0, dim1=1)
print(a.shape)
print(b.shape)c = torch.tensor([[[1, 2, 2], [3, 4, 3]]])
d = c.permute(1, 2, 0)
print(c.shape)
print(d.shape)

---

4、按条件筛选

函数	作用
torch.index_select(input, dim, index)	从输入张量中按索引选择某些元素
torch.nonzero(input)	获取张量中非零元素的索引
torch.masked_select(input, masked)	根据掩码（mask）从输入张量中选择元素
torch.gather(input, dim, index)	在指定维度上根据索引从输入张量中选择元素
torch.scatter(input, dim, index, src)	在指定维度（dim）上根据指定的索引（index），将源张量（src）的值散射到目标张量（input）中

 1）index_select

torch.index_select(input, dim, index) : 从输入张量中按索引选择某些元素，并返回一个新的张量

import torchtensor = torch.tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])# 创建一个要选择的索引张量
indices = torch.tensor([0, 2])# 在第0维上使用index_select选择索引为0和2的行
selected_rows = torch.index_select(tensor, 0, indices)print("Selected rows:\n", selected_rows)

2）nonzero

torch.nonzero(input) : 获取张量中非零元素的索引

import torchtensor = torch.tensor([[0, 1, 0],[2, 0, 3],[0, 4, 0]])# 获取非零元素的索引
nonzero_indices = torch.nonzero(tensor)
print("Non-zero indices:\n", nonzero_indices)

 

3）masked_select

torch.masked_select(input, masked) ： 根据掩码（mask）从输入张量中选择元素

import torch# 创建一个示例张量
input_tensor = torch.tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])# 创建一个掩码张量
mask_tensor = torch.tensor([[0, 1, 0],[1, 0, 1],[0, 1, 0]], dtype=torch.bool)# 使用掩码选择张量中的元素
selected_tensor = torch.masked_select(input_tensor, mask_tensor)
print("Selected tensor:\n", selected_tensor)

4）gather

torch.gather(input, dim, index) : 在指定维度上根据索引从输入张量中选择元素。若 dim=n ：

• 要求除了第n个维度，input_tensor 和 index_tensor 其他维度数量一致

• 在第n个维度上，通过 index_tensor 指定的索引，从 input_tensor 中取出对应位置的元素。

import torch# 创建一个示例张量
input_tensor = torch.tensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])# 创建一个示例索引张量
index_tensor = torch.tensor([[0, 2],[1, 0],[2, 1]])# 在第1维度上使用索引张量收集值
gathered_tensor = torch.gather(input_tensor, 1, index_tensor)print("Gathered tensor:\n", gathered_tensor)

 

5）scatter

torch.scatter(input, dim, index, src) ：在指定维度（dim）上根据指定的索引（index），将源张量（src）的值放到目标张量（input）中

• src 的形状 和 index的形状 必须保持一致，否则会报错

import torch# 创建一个示例目标张量
input_tensor = torch.zeros((4, 4), dtype=torch.int32)# 创建一个示例索引张量
index_tensor = torch.tensor([[0, 1],[2, 3]], dtype=torch.long)# 创建一个示例源张量
src_tensor = torch.tensor([[1, 2],[3, 4]], dtype=torch.int32)# 在第1维度上使用索引张量散射值
scattered_tensor = torch.scatter(input_tensor, 1, index_tensor, src_tensor)
print("Scattered tensor:\n", scattered_tensor)

 

No. 1

• src_tensor 第0行第0列的值为“1”

• index_tensor 第0行第0列的值为“0”， dim=1 表示 “0” 是列索引

• 将 “1” 放到 input_tensor 中，对应行第“0”列的位置上

No. 2

• src_tensor 第0行第1列的值为“2”，

• index_tensor 第0行第1列的值为“1”，dim=1 表示 “1” 是列索引

• 将 “2” 放到 input_tensor 中，对应行第“1”列的位置上

No. 3

• src_tensor 第1行第0列的值为“3”，

• index_tensor 第1行第0列的值为“2”，dim=1 表示 “2” 是列索引

• 将 “3” 放到 input_tensor 中，对应行第“2”列的位置上

No. 4

• src_tensor 第1行第1列的值为“4”，

• index_tensor 第1行第1列的值为“3”，dim=1 表示 “3” 是列索引

• 将 “4” 放到 input_tensor 中，对应行第“3”列的位置上

---

5、运算操作

函数	作用
torch.abs()	取绝对值
torch.add()	相加
torch.addcdiv(input, tensor1, tensor2, value)	result =input + value * tensor1 / tensor2
torch.addcmul(input, tensor1, tensor2, value)	result =input + value * tensor1 * tensor2
torch.ceil()	向上取整
torch.floor()	向下取整
torch.clamp(input, min, max)	对张量的元素进行截断操作，将超出指定范围的元素限制在指定范围内
torch.exp() / torch.log() / torch.pow	指数 / 对数 / 幂
torch.mul()	逐元素乘法，效果和 * 一样
torch.neg()	取反
torch.sqrt()	开根号
torch.sign()	取符号

 1）abs

import torchx = torch.arange(-5, 5)
y = torch.abs(x)
print(y)

2）add

import torchx = torch.arange(2, 5)
y = torch.arange(4, 7)
z = torch.add(x, y)
print(z)

 

3）addcdiv

  torch.addcdiv(input, tensor1, tensor2, value)

result =input + value * tensor1 / tensor2

import torcht = torch.randn(1, 3)
t1 = torch.randn(3, 1)
t2 = torch.randn(1, 3)a = t + 0.1 *(t1 / t2)
print(a)b = torch.addcdiv(t, t1, t2, value=0.1)
print(b)

 

4）addcmul

torch.addcmul(input, tensor1, tensor2, value)

result =input + value * tensor1 * tensor2

import torcht = torch.randn(1, 3)
t1 = torch.randn(3, 1)
t2 = torch.randn(1, 3)a = t + 0.1 * t1 * t2
print(a)b = torch.addcmul(t, t1, t2, value=0.1)
print(b)

 

5）ceil、floor

• torch.ceil(input) ：向上取整

• torch.floor(input) ：向下取整

import torchtorch.manual_seed(8)
x = torch.randn(3) * 10
y = torch.ceil(x)
z = torch.floor(x)
print(x)  
print(y) 
print(z)

6）clamp

  将张量元素大小限制在指定区间范围内

import torchx = torch.arange(1, 8)
y = torch.clamp(x, 2, 5)
print(y)

 

7）exp、log、pow

import torchtorch.manual_seed(8)
x = torch.arange(3)
print(x)
print(torch.exp(x))
print(torch.log(x))  # 以e为底
print(torch.pow(x, 3)) 

8）mul

  逐元素乘法，效果和 * 一样

import torcha = torch.tensor([[2, 2, 2],[2, 3, 4]])b = torch.tensor([[3, 3, 3],[4, 5, 6]])print(torch.mul(a,b))
print(a*b)

 

9）neg、sqrt、sign

• torch.neg() 取反

• torch.sqrt() 开根号

• torch.sign() 取符号

import torcha = torch.tensor([[2, -2, 2], [2, -3, 4]])print(torch.neg(a)) print(torch.sqrt(a))print(torch.sign(a))

---

6、统计操作

函数	作用
torch.sum() / torch.prod()	求和 / 求积
torch.cumsum() / torch.cumprod()	在指定维度上进行累加 / 在指定维度上进行累乘
torch.mean()、torch.median()	均值 / 中位数
torch.std() / torch.var()	标准差 / 方差
torch.norm(t, p)	t 的 p阶范数
torch.dist(a, b, p)	a，b 之间的 p阶范数

1）sum、prod、cumsum、cumprod

import torcha = torch.linspace(0, 10, 6).view(2, 3)
print(a)b = a.sum(dim=0)
c = torch.cumsum(a, dim=0)
print('\n维度0上求和 与 累加')
print(b)
print(c)d = a.prod(dim=1)
e = torch.cumprod(a, dim=1)
print('\n维度0上求积 与 累积')
print(d)
print(e)

 

2）mean、median

import torcha = torch.tensor([[2., 2., 5.],[3., 3., 8.],[4., 4., 4.]])print('求均值')
print(torch.mean(a))
print(torch.mean(a, 0))
print(torch.mean(a, 1))print('\n求中位数')
print(torch.median(a))
print(torch.median(a, 0))
print(torch.median(a, 1))

3）std、var

import torch# 创建示例张量
a = torch.tensor([[1.0, 2.0],[3.0, 4.0]])# 计算张量的标准差
std_value = torch.std(a)
print("Standard deviation:", std_value)# 计算张量的方差
var_value = torch.var(a)
print("Variance:", var_value)

 

4）norm、dist

• torch.norm(t, p) ：t 的 p阶范数

• torch.dist(a, b, p) ：a，b 之间的 p阶范数

import torch# 创建示例张量
tensor1 = torch.tensor([1.0, 2.0, 3.0])
tensor2 = torch.tensor([4.0, 5.0, 6.0])# 使用 torch.norm() 计算张量的范数
norm_value = torch.norm(tensor1)
print("tensor1 的L2范数:", norm_value)# 使用 torch.dist() 计算两个张量的范数
dist_value = torch.dist(tensor1, tensor2)
print("tensor1 和 tensor2 之间的L2范数:", dist_value)

---

7、比较操作

函数	作用
torch.eq	比较 tensor 是否相等 （支持 broadcast）
torch.equal	比较 tensor 是否有相同的 shape 与 值
torch.gt / torch.lt	大于 / 小于 gt : great than ; lt : less than
torch.ge / torch.le	大于等于 / 小于等于 ge : greater than or equal to ; le : less than or equal to
torch.max / torch.min(t,axis)	最大值 / 最小值
torch.topk(t, k, axis)	在指定维度上（axis）取最高的 k个值

 1）eq、 equal

import torch# 示例张量
t = torch.tensor([[1, 2, 3],[4, 5, 6]])# 使用eq()比较张量中的元素是否等于2
result_eq = torch.eq(t, 2)
print("Result of eq():\n", result_eq)# 使用equal()比较两个张量是否相等
t1 = torch.tensor([[1, 2, 3],[4, 5, 6]])
t2 = torch.tensor([[1, 2, 3],[4, 5, 6]])
result_equal = torch.equal(t1, t2)
print("\nResult of equal():", result_equal)

2）gt、 lt、ge、 le

import torch# 示例张量
t = torch.tensor([[1, 2, 3],[4, 5, 6]])# 使用gt()比较张量中的元素是否大于3
result_gt = torch.gt(t, 3)
print("Result of gt():\n", result_gt)# 使用lt()比较张量中的元素是否小于3
result_lt = torch.lt(t, 3)
print("\nResult of lt():\n", result_lt)# 使用gt()比较张量中的元素是否大于等于3
result_ge = torch.ge(t, 3)
print("\nResult of ge():\n", result_ge)# 使用le()比较张量中的元素是否小于等于3
result_le = torch.le(t, 3)
print("\nResult of le():\n", result_le)

 

3）max、min

import torch# 示例张量
t = torch.tensor([[1, 2, 3],[4, 5, 6]])# 计算张量的最大值和最小值
max_value = torch.max(t)
min_value = torch.min(t)
print("Max value:", max_value)
print("Min value:", min_value)# 沿着指定维度计算张量的最大值和最小值
max_value_axis_0 = torch.max(t, axis=0)
min_value_axis_1 = torch.min(t, axis=1)
print("\n沿0维上的最大值:", max_value_axis_0.values)
print("沿0维上的最大值索引:", max_value_axis_0.indices)
print("沿1维上的最小值:", min_value_axis_1.values)
print("沿1维上的最小值索引:", min_value_axis_1.indices)

4）topk

import torch# 示例张量
t = torch.tensor([[1, 2, 3],[4, 5, 6]])# 沿着指定维度获取张量中最大的两个值及其索引
topk_values, topk_indices = torch.topk(t, k=2, dim=1)
print("沿维度1上的最大的2个值:\n", topk_values)
print("\n沿维度1上的最大的2个值的索引:\n", topk_indices)

 

---

8、矩阵操作

函数	作用
torch.dot(t1, t2)	计算 1维张量的内积或点积
torch.mul(t1, t2)	逐元素相乘
torch.mm(t1, t2) / torch.mv(t, v)	计算矩阵乘法 / 计算矩阵t与向量v 的乘法
bmm	含 batch 的 3D 矩阵乘法
svd	计算 t 的 SVD分解

 1）dot

  Torch的 dot 只能对两个 一维张量 进行点积运算，否则会报错；Numpy中的dot无此限制。

import torcha = torch.tensor([2, 3])
b = torch.tensor([3, 4])print(torch.dot(a, b))

import torcha = torch.tensor([[2, 3],[3, 4]])b = torch.tensor([[3, 4],[1, 2]])print(torch.dot(a, b))

2）mul

• a 和 b 必须尺寸相同。

• torch.mul(a, b) 和 a * b 效果一样

• torch.mul(a, b) 是逐元素相乘，torch.mm(a, b) 是矩阵相乘

import torcha = torch.tensor([[2, 3],[3, 4]])b = torch.tensor([[3, 4],[1, 2]])print(torch.mul(a, b))
print(a * b)
print(torch.mm(a, b))

 

3）mm、mv

• torch.mm(t1, t2) 是矩阵相乘， torch.mv(t, v) 矩阵与向量乘法

• torch.mv(t, v) , 矩阵t为第一个参数，向量v为第二个参数，位置不能换，否则会报错

import torcha = torch.tensor([[1, 2, 3],[2, 3, 4]])b = torch.tensor([[1, 2],[1, 2],[3, 4]])c = torch.tensor([1, 2, 3])print(torch.mm(a, b))
print(torch.mv(a, c))

 

4）bmm 

import torchbatch1 = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=torch.float32)  # Shape: (2, 2, 2)
batch2 = torch.tensor([[[2, 0], [0, 2]], [[1, 0], [0, 1]]], dtype=torch.float32)  # Shape: (2, 2, 2)result = torch.bmm(batch1, batch2)
print("Result:\n", result)

5）svd

import torcha = torch.randn(2, 3)
print(torch.svd(a))