pytorch高阶操作

最新推荐文章于 2022-11-24 20:38:36 发布
最新推荐文章于 2022-11-24 20:38:36 发布
阅读量206 收藏 2
点赞数
分类专栏： 深度学习与pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41845951/article/details/118734348
版权

目录

broadcast广播机制

合并与分割

cat拼接

stack创建新维度

split按长度拆分和chunk按数量拆分

数学运算

add/sub/mul/div加减乘除

matmul矩阵相乘

pow矩阵的次方以及sqrt/rsqrt/exp/log

round矩阵近似运算

clamp(裁剪)

统计属性

norm范数,prod张量元素累乘(阶乘)

mean/sum/max/min/argmin/argmax

kthvalue()和topk()

比较运算符号>,>=,<,<=,!=,==

 高阶操作where和gather

torch.where

torch.gather

broadcast广播机制

广播机制跟expand效果一样，但是它是自动扩展，不需要用torch.unsqueeze(index)进行维度增加，能够节省内存，思路如下：

主要思想就是低维度tensor添加一个size=1的维度，然后对所有size=1的维度扩展，其余维度不变。

输入：

a=torch.rand(4,32,14,14)
b=torch.rand(1,32,1,1)
c=torch.rand(32,1,1)

输出：

torch.Size([4, 32, 14, 14])
torch.Size([4, 32, 14, 14])

合并与分割

cat拼接

输入：

# 两个班级a和b,各有32个学生，8门成绩。
a = torch.rand(4, 32, 8)
b = torch.rand(5, 32, 8)
# 按照班级进行合并起来,dim=n表示在n维度进行拼接，即对应维度数值相加
print(torch.cat([a, b], dim=0).shape)

输出：

torch.Size([9, 32, 8])

stack创建新维度

输入：

a1 = torch.rand(4, 3, 32, 32)
a2 = torch.rand(4, 3, 32, 32)
print(torch.cat([a1, a2], dim=1).shape)
print('====================================')
print(torch.stack([a1, a2], dim=1).shape)    # 各自创建一个新的维度。然后concat

a = torch.rand(32, 8)
b = torch.rand(32, 8)
print(torch.stack([a, b], dim=0).shape)

输出：

torch.Size([4, 6, 32, 32])
====================================
torch.Size([4, 2, 3, 32, 32])   # 各自创建一个新的维度。然后concat
torch.Size([2, 32, 8])

例子：两个班，每个班有32个人，每个人有8门成绩，现在要将两个班成绩合并成一张表，显然不能直接用cat拼接即64个学生，每个学生有8门成绩，应该是有两个班，每个班32名学生，每个学生8门成绩，即[2, 32, 8]

split按长度拆分和chunk按数量拆分

tensor.split(n，dim),n表示拆分后的长度，dim表示要拆分的维度。

输入：

c = torch.rand(3, 32, 8)
aa, bb = c.split([2, 1], dim=0)
print(aa.shape)
print(bb.shape)
print('====================================')
aa, bb = c.split(2, dim=0)
print(aa.shape)
print(bb.shape)

输出：

torch.Size([2, 32, 8])
torch.Size([1, 32, 8])
====================================
torch.Size([2, 32, 8])
torch.Size([1, 32, 8])
 tensor.chunk(n，dim)，n表示要拆分成几部分，dim表示要拆分的维度。

输入：

c = torch.rand(6, 32, 8)
aa, bb, cc= c.chunk(3, dim=0)  # 第1个参数要拆分后的数量
print(aa.shape)
print(bb.shape)
print(cc.shape)

输出：

torch.Size([2, 32, 8])
torch.Size([2, 32, 8])
torch.Size([2, 32, 8])

数学运算

add/sub/mul/div加减乘除

输入：

a = torch.rand(3, 4)
b = torch.rand(4)

print(a)
print(b)
print(a+b)
print(torch.mul(a,b))

print(torch.all(torch.eq(a-b, torch.sub(a, b))))
print(torch.all(torch.eq(a*b, torch.mul(a, b))))
print(torch.all(torch.eq(a/b, torch.div(a, b))))

输出：

tensor([[0.9546, 0.8925, 0.8478, 0.8498],
        [0.5096, 0.6845, 0.3661, 0.5274],
        [0.4793, 0.2723, 0.4199, 0.0719]])
tensor([0.4801, 0.9741, 0.0383, 0.6885])
tensor([[1.4347, 1.8666, 0.8861, 1.5383],
        [0.9898, 1.6585, 0.4044, 1.2159],
        [0.9595, 1.2463, 0.4582, 0.7604]])
tensor([[0.4583, 0.8694, 0.0325, 0.5851],
        [0.2447, 0.6667, 0.0140, 0.3631],
        [0.2302, 0.2652, 0.0161, 0.0495]])
tensor(True)
tensor(True)
tensor(True)


matmul矩阵相乘

注意：torch.mm只适用于2D，一般使用torch.matmul,@符号等同于troch.matmul

输入：

a = torch.tensor([[3., 3.], [3., 3.]])
b = torch.ones(2, 2)
print(torch.mm(a, b))
print(torch.matmul(a, b))
print(a@b)

输出：

tensor([[6., 6.],
        [6., 6.]])
tensor([[6., 6.],
        [6., 6.]])
tensor([[6., 6.],
        [6., 6.]])

对于3D和4D矩阵相乘

输入：

a = torch.rand(4, 3, 28, 64)
b = torch.rand(4, 3, 64, 32)

# 这就是4D的tensor矩阵相乘，这种规则是符合实际规则的。
# 这其实就是支持多个矩阵对并行相乘。
# 只取低的维度(右边)参与运算，就是[28,64]@[64,32]
print(torch.matmul(a, b).shape)

print('================================')
c = torch.rand(4, 1, 64, 32) # 这里使用使用broadcasting机制，把dim的size为1的变为一致。
print(torch.matmul(a, c).shape)

输出：

torch.Size([4, 3, 28, 32])
================================
torch.Size([4, 3, 28, 32])

pow矩阵的次方以及sqrt/rsqrt/exp/log

pow(tensor, 次方)第一个参数为Tensor，第二个参数表示次方，比如2次方，三次方，四次方等等。

输入：

a =torch.full([2, 2], 3) # 使用torch.full函数创建一个shape[2, 2],元素全部为3的张量
print(a.pow(2))
print(torch.pow(a, 2))
print(a**2)
print('=============================')
b = a**2
print(b.sqrt())
print(b.rsqrt())         # 平方根的导数

c = torch.exp(torch.ones(2, 2))
print(c)
print(torch.log(c))     # 默认以e为底,使用2为底或者其他的，自己设置.

输出：

tensor([[9, 9],
        [9, 9]])
tensor([[9, 9],
        [9, 9]])
tensor([[9, 9],
        [9, 9]])
=============================
tensor([[3., 3.],
        [3., 3.]])
tensor([[0.3333, 0.3333],
        [0.3333, 0.3333]])
tensor([[2.7183, 2.7183],
        [2.7183, 2.7183]])
tensor([[1., 1.],
        [1., 1.]])


round矩阵近似运算

输入：

a = torch.tensor(3.14)
# .floor()向下取整，.ceil()向上取整，.trunc()截取整数，.frac截取小数。
print(a.floor(), a.ceil(), a.trunc(), a.frac())

print(a.round())
b = torch.tensor(3.5)
print(b.round())

输出：

tensor(3.) tensor(4.) tensor(3.) tensor(0.1400)
tensor(3.)

clamp(裁剪)

a.clamp(min):表示tensor a中小于10的都赋值为10，表示最小值为10；

输入：

grad = torch.rand(2, 3)*15
print(grad)
print(grad.max(), grad.median(), grad.min())
print('============================================')
print(grad.clamp(10))     # 最小值限定为10，小于10的都变为10；

print(grad.clamp(8, 15))
print(torch.clamp(grad, 8, 15))

输出：

tensor([[ 4.9132, 11.6007,  8.3476],
        [11.6155,  2.1120,  4.3543]])
tensor(11.6155) tensor(4.9132) tensor(2.1120)
============================================
tensor([[10.0000, 11.6007, 10.0000],
        [11.6155, 10.0000, 10.0000]])
tensor([[ 8.0000, 11.6007,  8.3476],
        [11.6155,  8.0000,  8.0000]])
tensor([[ 8.0000, 11.6007,  8.3476],
        [11.6155,  8.0000,  8.0000]])

统计属性

norm范数,prod张量元素累乘(阶乘)

输入：

a = torch.full([8], 1)
b = a.view(2, 4)
c = a.view(2, 2, 2)
print(a, '\n', b,'\n', c)
print('=============================================')
print(a.norm(1), b.norm(1), c.norm(1))
print(a.norm(2), b.norm(2), c.norm(2))
print('=============================================')
print(b.norm(1, dim=1))
print(b.norm(2, dim=1))
print('=============================================')
print(c.norm(1, dim=0))
print(c.norm(2, dim=0))
print(torch.norm(c, p=2, dim=0)) # 同一个表达，p=2可以省略，默认就是2

输出：

tensor([1., 1., 1., 1., 1., 1., 1., 1.]) 
 tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.]]) 
 tensor([[[1., 1.],
         [1., 1.]],

        [[1., 1.],
         [1., 1.]]])
=============================================
tensor(8.) tensor(8.) tensor(8.)
tensor(2.8284) tensor(2.8284) tensor(2.8284)
=============================================
tensor([4., 4.])
tensor([2., 2.])
=============================================
tensor([[2., 2.],
        [2., 2.]])
tensor([[1.4142, 1.4142],
        [1.4142, 1.4142]])
tensor([[1.4142, 1.4142],
        [1.4142, 1.4142]])

mean/sum/max/min/argmin/argmax

输入：

a = torch.rand(2, 4)
print(a)
print(a.max(), a.min(), a.mean())
print(a.prod()) # 最大值，最小值，均值，prod表示累乘也就是阶乘。
print(a.sum())  # 累加操作。

print(a.argmax(), a.argmin())

输出：

tensor([[0.6793, 0.8178, 0.2579, 0.8237],
        [0.3547, 0.0144, 0.6213, 0.8617]])
tensor(0.8617) tensor(0.0144) tensor(0.5538)
tensor(0.0003)
tensor(4.4306)
tensor(7) tensor(5)
 

kthvalue()和topk()

注意：topk(3, dim=1)(最大的3个)返回结果如下图所示，如果把largest设置为False就是默认最小的几个。kthvalue(k，dim=1)表示第k小的(默认表示小的)。下面图中的一共10中可能，第8小就是表示第3大。

输入：

a = torch.rand(5, 10)
print(a.topk(3, dim=1))       # 最大的3个元素，和对应的index
print('==========================================================')
print(a.topk(3, dim=1, largest=False))  # 最小的3个元素，和对应的index
print('==========================================================')
print(a.kthvalue(3))
print(a.kthvalue(3,dim=1))

输出：

torch.return_types.topk(
values=tensor([[0.9602, 0.9356, 0.8556],
        [0.8850, 0.8361, 0.7804],
        [0.9984, 0.9755, 0.9478],
        [0.9764, 0.8199, 0.7747],
        [0.9959, 0.9958, 0.8644]]),
indices=tensor([[7, 9, 4],
        [8, 7, 6],
        [8, 6, 5],
        [2, 9, 3],
        [6, 3, 9]]))
==========================================================
torch.return_types.topk(
values=tensor([[0.0910, 0.1869, 0.2590],
        [0.0592, 0.0888, 0.2776],
        [0.0441, 0.1750, 0.2086],
        [0.0238, 0.2317, 0.2618],
        [0.0161, 0.1566, 0.2587]]),
indices=tensor([[0, 3, 2],
        [0, 5, 4],
        [9, 0, 7],
        [5, 8, 4],
        [1, 2, 8]]))
==========================================================
torch.return_types.kthvalue(
values=tensor([0.2590, 0.2776, 0.2086, 0.2618, 0.2587]),
indices=tensor([2, 4, 7, 4, 8]))
torch.return_types.kthvalue(
values=tensor([0.2590, 0.2776, 0.2086, 0.2618, 0.2587]),
indices=tensor([2, 4, 7, 4, 8]))

比较运算符号>,>=,<,<=,!=,==

输入：

a = torch.rand(5, 5)
print(a>0.2)
print(torch.gt(a, 0.2))
print(a!=0)

输出：

tensor([[ True,  True,  True, False,  True],
        [False, False, False, False,  True],
        [ True,  True,  True,  True,  True],
        [ True,  True,  True,  True, False],
        [ True,  True,  True, False, False]])
tensor([[ True,  True,  True, False,  True],
        [False, False, False, False,  True],
        [ True,  True,  True,  True,  True],
        [ True,  True,  True,  True, False],
        [ True,  True,  True, False, False]])
tensor([[True, True, True, True, True],
        [True, True, True, True, True],
        [True, True, True, True, True],
        [True, True, True, True, True],
        [True, True, True, True, True]])

 高阶操作where和gather

torch.where

torch.where(condition,x,y)-->tensor 表示如果满足condition则返回x，否则返回y

输入：

cond=torch.tensor([[0.66,0.77],[0.56,0.423]])
a=torch.tensor([[0.,0.],[0.,0.]])
b=torch.tensor([[1.,1.],[1.,1.]])
print(torch.where(cond>0.6,a,b))

输出：

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

torch.gather

error:404..
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch张量求n的阶乘
飞机火车巴雷特的博客
12-01 1820
对pytorch张量求n的阶乘
PyTorch进阶操作
Swayzzu的博客
11-01 207
目录 一、合并与分割 1.cat拼接 2.stack堆叠 3.拆分 ①Split按长度拆分 ②Chunk按数量拆分 二、基本运算 1.加减乘除 2.矩阵相乘 3.次方计算 4. clamp 三、属性统计 1.求范数 2.求极值、求和、累乘 3. dim和keepdim 4.topk和kthvalue 5.比较运算 6.高阶操作 ①where ②gather 一、合并与分割 1.cat拼接 直接按照指定的dim维度进行合并，要求除了所需要合并的维度之外，其他.
Pytorch的一些高阶操作整理
Data _designer
04-10 460
看到别人代码里惯用的一些操作，觉得自己的代码真的太low了。 1. topk 2. where 3.gather：某一维度，根据每行都选择该列维度 4. einsum
看深度学习代码遇见的一些torch用法
Spanish_pie的博客
11-24 448
torch.arange(batch_size).view(-1, 1).to(device), # arrange返回大小为(end-start)/step的一维张量。torch.eq 对两个张量Tensor进行逐元素的比较，若相同位置的两个元素相同，则返回True；torch.ones_like(mask), # 返回一个填充了标量值1的张量，其大小与mask相同。torch.ones_like(mask) 返回一个填充了标量值1的张量，其大小与mask相同。torch.div 数组的点除运算。
详解PyTorch中Tensor的高阶操作
09-18
本文主要探讨了PyTorch中Tensor的高阶操作，这些操作提供了更高级的数学和逻辑功能，有助于处理复杂的数学问题和神经网络计算。我们将详细介绍两个关键的高阶操作：`torch.where()`和`torch.gather()`。 1. **条件...
Pytorch高阶OP操作where，gather原理
09-16
在PyTorch中，高阶操作（High-level Operations）提供了许多强大的工具，使得开发者能够更加高效地编写深度学习模型。本文将重点探讨其中的两个重要操作：`where`和`gather`，它们在处理和操纵张量数据时起着至关...
算法剪枝-基于Pytorch使用高阶特征图实现的过滤器算法剪枝-算法优化-附项目源码-优质项目实战.zip
最新发布
05-20
算法剪枝_基于Pytorch使用高阶特征图实现的过滤器算法剪枝_算法优化_附项目源码_优质项目实战
Pytorch-Tensor(张量)
Fujh-nk的博客
08-18 763
Tensor的基本数值类型 Tensor(张量)的创建 1. 直接创建 torch.ones(int[, int[, int[, ...]]]) -> 创建一个1填充的矩阵 torch.zeros(int[, int[, int[, ...]]], dtype=type) -> 创建一个0填充的矩阵，并指定数据类型 torch.empty(int[, int[, i...
pytorch:torch.mm()和torch.matmul()
大雄没有叮当猫的博客
09-11 6万+
微信公众号:数据挖掘和分析学习 torch.mm(mat1, mat2, out=None) → Tensor torch.matmul(mat1, mat2, out=None) → Tensor 对矩阵mat1和mat2进行相乘。 如果mat1 是一个n×m张量，mat2 是一个 m×p 张量，将会输出一个 n×p 张量out。 参数 ： mat1 (Tensor) – 第一个相乘矩...
python计算阶乘和的方法(1!+2!+3!+…+n!)
12-31
方法一：使用while循环来计算 n = int(input()) jie = 1 sum = 0 i = 1 while n >= i: jie = jie * i sum = sum + jie i = i + 1 print(sum) 方法二：使用递归函数调用阶乘方法求和（其中n的值在1~40之间） def jie(n): if n == 1: return 1 else: return n*jie(n-1) n = int(input()) sum = 0 if n 40: print(请重新输入数据) else:
pytorch matmul和mm和bmm区别
Leokb24的博客
05-08 2万+
结论 从官方文档可以看出, mm只能进行矩阵乘法,也就是输入的两个tensor维度只能是(n×m)(n\times m)(n×m)和(m×p)(m\times p)(m×p), 而matmul可以进行张量乘法, 输入可以是高维. ...
Spring BcryptPasswordEncorder Log Rounds参数说明
要坚持，要认真。
09-05 1281
Spring BcryptPasswordEncorder log rounds参数说明今天在做用户上传Excel表格导入数据到Mongodb数据库的时候遇到一个超时的问题，比较有意思，在这里记录一下！需求是这样的，用户通过页面选择本地的Excel表格，通过接口将Excel表格上传到后台，由后端解析Excel表格中的数据，解析成功后保存到数据库中。对于Excel表格的处理我表示轻车熟路，本来这个功能
【Pytorch学习】Pytorch安装遇到的错误及解决方法
weixin_45626095的博客
08-08 1万+
在Anaconda环境和Pycharm软件的基础上安装Pytorch深度学习框架。
Pytorch 一些高阶操作
洪流之源
06-26 1159
1.where 使用C=torch.where(condition,A,B)其中A,B,C,condition是shape相同的Tensor，C中的某些元素来自A，某些元素来自B，这由condition中对应位置的元素是1还是0来决定。如果condition对应位置元素是1，则C中的该位置的元素来自A中的该位置的元素，如果condition对应位置元素是0，则C中的该位置的元素来自B中的该位置...
Python计算阶乘的三种方法
小小臭臭的博客
09-16 4801
# 递归 def func(n): if n == 0 or n == 1: return 1 else: return (n * func(n - 1)) # reduce函数 + lambda函数 from functools import reduce def fact(n): return reduce(lambda a, b...
pytorch的基本操作
qq_41845951的博客
07-13 226
创建tensor torch与numpy相互转化 a=np.array([2,2.2]) torch.from_numpy(a) a=torch.tensor([2.,3]) b=a.numpy() 直接创建tensor a=torch.tensor([2.,3]) a=torch.FloatTensor([[2,5],[2.,3]]) 根据数值要求: torch.zeros(*sizes, out=None, ..)# 返回大小为sizes的零矩阵 torch.ze...
求N的阶乘N！中末尾0的个数
weixin_30555125的博客
01-26 407
有道问题是这样的：给定一个正整数N，那么N的阶乘N！末尾中有多少个0呢？例如：N=10，N！=3628800,则N！的末尾有两个0； 直接上干货，算法思想如下： 对于任意一个正整数N！，都可以化为N！= （2^X) * （3^Y）* （5^Z）......的形式，要求得末尾0的个数只需求得min(X, Z)即可， 由于是求N！，则X >= Z; 即公约数5出现的频率小于等于2出现的频...
python学习——计算阶乘的几种方法
热门推荐
geerniya的博客
08-19 12万+
方法一： 很普通的for循环语句：a = 1 n = 5 for i in range(1,n+1): a = a * i print(a)得到结果：120方法二： 采用上篇博文提到的reduce()函数：from functools import reduce n = 5 print(reduce(lambda x,y:x*y,range(1,n+1))) 得到结果：120方法三：
pytorch einsum
07-27
引用\[3\]中提供了一个高阶张量运算的示例。在这个示例中，使用`np.einsum('ijk,jil->kl', a, b)`计算了两个3阶张量a和b的乘积，并生成了一个2阶张量o。这个示例中的公式解析为对i和j进行求和，然后将结果存储在输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值