torch.add、sub、mul、div、matmul、mm、@、pow、exp、log、sqrt运算

已于 2023-05-18 20:06:12 修改
阅读量4.2k 收藏 28
点赞数 7
分类专栏： pytorch python 文章标签： pytorch python 深度学习
于 2021-08-20 17:55:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjw_zyfx/article/details/119829037
版权
python 同时被 2 个专栏收录
125 篇文章 2 订阅
订阅专栏
pytorch
69 篇文章 8 订阅
订阅专栏 
a = torch.rand(2, 3)
b = torch.rand(2, 3)
print(a)
print(b)

add 加法运算

import torch

# 加法运算的几种方式
print('a + b\n', a + b)
print('a.add(b)\n', a.add(b))
print('torch.add(a, b)\n', torch.add(a, b))
# 仅这种方式会改变a的值，即把结果保存到a中
print('a.add_(b)\n', a.add_(b))
print(a)

结果：

tensor([[0.9993, 0.9160, 0.4045],
        [0.6335, 0.2120, 0.6178]])
tensor([[0.8361, 0.6041, 0.1181],
        [0.5700, 0.5781, 0.6998]])
a + b
 tensor([[1.8354, 1.5201, 0.5226],
        [1.2035, 0.7901, 1.3176]])
a.add(b)
 tensor([[1.8354, 1.5201, 0.5226],
        [1.2035, 0.7901, 1.3176]])
torch.add(a, b)
 tensor([[1.8354, 1.5201, 0.5226],
        [1.2035, 0.7901, 1.3176]])
a.add_(b)
 tensor([[1.8354, 1.5201, 0.5226],
        [1.2035, 0.7901, 1.3176]])
tensor([[1.8354, 1.5201, 0.5226],
        [1.2035, 0.7901, 1.3176]])

sub 减法：

import torch

a = torch.rand(2, 3)
b = torch.rand(2, 3)
print(a)
print(b)
print('减法操作')
print('a\n', a)
print('a-b\n', a-b)
print('a.sub(b)\n', a.sub(b))
print('torch.sub(a, b)\n', torch.sub(a, b))
print('a.sub_(b)\n', a.sub_(b))
print(a)

结果：

tensor([[0.8540, 0.5175, 0.9498],
        [0.8799, 0.8251, 0.7269]])
tensor([[0.2576, 0.6812, 0.9487],
        [0.1363, 0.7312, 0.4687]])
减法操作
a
 tensor([[0.8540, 0.5175, 0.9498],
        [0.8799, 0.8251, 0.7269]])
a-b
 tensor([[ 0.5964, -0.1637,  0.0011],
        [ 0.7437,  0.0939,  0.2582]])
a.sub(b)
 tensor([[ 0.5964, -0.1637,  0.0011],
        [ 0.7437,  0.0939,  0.2582]])
torch.sub(a, b)
 tensor([[ 0.5964, -0.1637,  0.0011],
        [ 0.7437,  0.0939,  0.2582]])
a.sub_(b)
 tensor([[ 0.5964, -0.1637,  0.0011],
        [ 0.7437,  0.0939,  0.2582]])
tensor([[ 0.5964, -0.1637,  0.0011],
        [ 0.7437,  0.0939,  0.2582]])

mul 乘法：

import torch

a = torch.rand(2, 3)
b = torch.rand(2, 3)
print(a)
print(b)
print('乘法: 对应位置上的元素相乘')
print('a\n', a)
print('a*b\n', a*b)
print('torch.mul(a, b)\n', torch.mul(a, b))
print('a.mul(b)\n', a.mul(b))
print('a.mul_(b)\n', a.mul_(b))
print('a', a)

结果：


tensor([[0.6888, 0.6880, 0.8884],
        [0.9059, 0.8689, 0.5366]])
tensor([[0.5977, 0.1775, 0.9614],
        [0.4969, 0.8030, 0.6663]])
乘法: 对应位置上的元素相乘
a
 tensor([[0.6888, 0.6880, 0.8884],
        [0.9059, 0.8689, 0.5366]])
a*b
 tensor([[0.4117, 0.1221, 0.8541],
        [0.4501, 0.6977, 0.3575]])
torch.mul(a, b)
 tensor([[0.4117, 0.1221, 0.8541],
        [0.4501, 0.6977, 0.3575]])
a.mul(b)
 tensor([[0.4117, 0.1221, 0.8541],
        [0.4501, 0.6977, 0.3575]])
a.mul_(b)
 tensor([[0.4117, 0.1221, 0.8541],
        [0.4501, 0.6977, 0.3575]])
a tensor([[0.4117, 0.1221, 0.8541],
        [0.4501, 0.6977, 0.3575]])

div 除法

import torch

a = torch.rand(2, 3)
b = torch.rand(2, 3)
print(a)
print(b)
print('除法')
print('a\n', a)
print('a/b\n', a/b)
print('torch.div(a, b)\n', torch.div(a, b))
print('a.div(b)\n', a.div(b))
print('a.div_(b)\n', a.div_(b))
print('a', a)

结果：

tensor([[0.3184, 0.7036, 0.5756],
        [0.5146, 0.4399, 0.1367]])
tensor([[0.9408, 0.1757, 0.7494],
        [0.0198, 0.7022, 0.8607]])
除法
a
 tensor([[0.3184, 0.7036, 0.5756],
        [0.5146, 0.4399, 0.1367]])
a/b
 tensor([[ 0.3385,  4.0043,  0.7680],
        [25.9892,  0.6265,  0.1588]])
torch.div(a, b)
 tensor([[ 0.3385,  4.0043,  0.7680],
        [25.9892,  0.6265,  0.1588]])
a.div(b)
 tensor([[ 0.3385,  4.0043,  0.7680],
        [25.9892,  0.6265,  0.1588]])
a.div_(b)
 tensor([[ 0.3385,  4.0043,  0.7680],
        [25.9892,  0.6265,  0.1588]])
a tensor([[ 0.3385,  4.0043,  0.7680],
        [25.9892,  0.6265,  0.1588]])

@、matmul、mm矩阵运算

import torch
# 矩阵运算 matmul
a = torch.ones(2, 1)
b = torch.ones(1, 2)
print('a @ b\n', a @ b)
print('a.matmul(b)\n', a.matmul(b))
print('torch.matmul(a, b)\n', torch.matmul(a, b))
print('torch.mm(a, b)\n', torch.mm(a, b))
print('a.mm(b)\n', a.mm(b))

结果：


a @ b
 tensor([[1., 1.],
        [1., 1.]])
a.matmul(b)
 tensor([[1., 1.],
        [1., 1.]])
torch.matmul(a, b)
 tensor([[1., 1.],
        [1., 1.]])
torch.mm(a, b)
 tensor([[1., 1.],
        [1., 1.]])
a.mm(b)
 tensor([[1., 1.],
        [1., 1.]])

matmul高维矩阵运算

import torch
# 高维运算的时候要注意前边的维度一定要一样，后边的两个维度要和二维的一样即：
# 第一个的最后一个维度的数字，要和第二个的倒数第二个的数字一样
a = torch.ones(1, 2, 3, 4)
b = torch.ones(1, 2, 4, 3)
print(torch.matmul(a, b))
print(torch.matmul(a, b).shape)

结果：

tensor([[[[4., 4., 4.],
          [4., 4., 4.],
          [4., 4., 4.]],

         [[4., 4., 4.],
          [4., 4., 4.],
          [4., 4., 4.]]]])
torch.Size([1, 2, 3, 3])

pow指数运算

import torch
print('指数运算:即a中的每个元素的n次方 ')
a = torch.tensor([1, 2])
print('a\n', a)
print('torch.pow(a, 3)\n', torch.pow(a, 3))
print('a.pow(3)\n', a.pow(3))
print('a**3\n', a**3)
print('a.pow_(3)\n', a.pow_(3))
print('a\n', a)

结果：


指数运算:即a中的每个元素的n次方 
a
 tensor([1, 2])
torch.pow(a, 3)
 tensor([1, 8])
a.pow(3)
 tensor([1, 8])
a**3
 tensor([1, 8])
a.pow_(3)
 tensor([1, 8])
a
 tensor([1, 8])

exp的运算

import torch
print('e的运算：即 e的n次方 ')
# 注意必须要是float类型的否则会报错
a = torch.tensor([1, 2], dtype=torch.float32)
print('a\n', a)
print('torch.exp(a)\n', torch.exp(a))
print('torch.exp_(a)\n', torch.exp_(a))
a = torch.tensor([1, 2] , dtype=torch.float32)
print('a.exp()\n', a.exp())
print('a.exp_()', a.exp_())
print('a\n', a)

结果：


e的运算：即 e的n次方 
a
 tensor([1., 2.])
torch.exp(a)
 tensor([2.7183, 7.3891])
torch.exp_(a)
 tensor([2.7183, 7.3891])
a.exp()
 tensor([2.7183, 7.3891])
a.exp_() tensor([2.7183, 7.3891])
a
 tensor([2.7183, 7.3891])

log运算

import torch
print('log运算: log以1为底的')
a = torch.tensor([1, 2], dtype=torch.float32)
print('a\n', a)
print('torch.log(a)\n', torch.log(a))
print('torch.log_(a)', torch.log_(a))
a = torch.tensor([1, 2], dtype=torch.float32)
print('a.log()\n', a.log())
print('a.log_()\n', a.log_())
print('a\n', a)

结果：

log运算: log以1为底的
a
 tensor([1., 2.])
torch.log(a)
 tensor([0.0000, 0.6931])
torch.log_(a) tensor([0.0000, 0.6931])
a.log()
 tensor([0.0000, 0.6931])
a.log_()
 tensor([0.0000, 0.6931])
a
 tensor([0.0000, 0.6931])

sqrt开平方

import torch
print('开平方')
a = torch.tensor([4, 5], dtype=torch.float32)
print('a\n', a)
print('torch.sqrt(a)\n', torch.sqrt(a))
print('torch.sqrt_(a)\n', torch.sqrt_(a))
print('a\n', a)
a = torch.tensor([4, 5], dtype=torch.float32)
print('a.sqrt()\n', a.sqrt())
print('a.sqrt_()\n', a.sqrt_())
print('a\n', a)

结果：

开平方
a
 tensor([4., 5.])
torch.sqrt(a)
 tensor([2.0000, 2.2361])
torch.sqrt_(a)
 tensor([2.0000, 2.2361])
a
 tensor([2.0000, 2.2361])
a.sqrt()
 tensor([2.0000, 2.2361])
a.sqrt_()
 tensor([2.0000, 2.2361])
a
 tensor([2.0000, 2.2361])
jjw_zyfx
关注
  • 7
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Pytorch】进阶学习：实现矩阵乘法---torch.mul() 、 torch.mm() 和torch.matmul()的区别
m0_58477260的博客
04-15 1815
总结一下，torch.mm()和这三个函数的主要区别在于它们处理张量的方式和维度要求不同。执行的是元素级别的乘法，要求输入张量形状相同；torch.mm()执行的是标准的矩阵乘法，只适用于二维张量；而则提供了更广义的矩阵乘法，可以处理任意维度的张量，包括批量矩阵乘法。确保输入张量的形状符合函数的要求，否则可能会引发错误。对于矩阵乘法，需要注意矩阵的维度匹配问题，即第一个矩阵的列数必须等于第二个矩阵的行数。在进行批量矩阵乘法时，使用可以方便地处理多个矩阵的乘法运算。
torch.sub()与torch.sub_()函数用法
qq_40641713的博客
04-13 7365
介绍了pytorch中的torch.sub_()与torch.sub()函数的功能，以及两者的联系与区别
Pytorch常用乘法函数总结：torch.mul()、*、torch.mm()、torch.bmm()、torch.mv()、torch.dot()、@、torch.matmul()
最新发布
qq_43629945的博客
04-26 1619
torch.mul() 和 * 等价，为element-wise乘，可广播；torch.mm() 二维矩阵乘法，torch.bmm() 三维批量矩阵乘法，均不可广播；torch.mv(mat, vec) 为矩阵向量乘法，不可广播；torch.dot() 仅支持两个一维向量点积，返回一个标量数字；@ 矩阵乘法，等价于 torch.dot() + torch.mv() + torch.mm()；torch.matmul() 矩阵乘法，与 @ 类似，但它不止一维二维，可扩高维，可广播
Pytorch torch.add() torch.add_() 用法
百般回首曾经的相遇，留下的只是一缕残忆
07-26 1万+
Pytorch torch.add() torch.add_() 用法
使用numpy中的matmul方法计算矩阵乘法
weixin_41855010的博客
07-07 1391
我们在线性代数中学过的矩阵乘法比较特殊，需要对应的行列向量点乘之后累加，如以下公式所示：mij=∑k=1naikbkjm_{ij}=\sum_{k=1}^na_{ik}b_{kj}mij​=k=1∑n​aik​bkj​假设mijm_{ij}mij​为矩阵MMM中第iii行第jjj列位置上的元素，MMM的尺寸为a×ba×ba×b，aika_{ik}aik​为矩阵AAA中的元素，AAA的尺寸为a×na×na×n的矩阵，bkjb_{kj}bkj​为矩阵BBB中的元素，BBB的尺寸为n×bn×bn×b的矩阵，并且他
Numpy中矩阵运算
IT之一小佬的博客
02-19 1463
4.6 数学：矩阵 学习目标 目标 知道什么是矩阵和向量 知道矩阵的加法,乘法 知道矩阵的逆和转置 应用np.matmul、np.dot实现矩阵运算 1 矩阵和向量 1.1 矩阵 矩阵，英文matrix，和array的区别矩阵必须是2维的，但是array可以是多维的。 如图:这个是 3×2 矩阵，即 3 行 2 列，如 m 为行，n 为列，那么 m×n 即 3×2 矩阵的维数即行数×列数 矩阵元素(矩阵项): Aij 指第 i 行，第 j 列的元素。 1.2 向量
维度不同的 Tensor 也能相加 ？
qq_43799400的博客
08-16 4327
维度不同的 Tebsor 如何相加呢？但是是自动填充对应维度，使维度相同后再相加。 如 torch.Size([1, 2, 3, 4]) 与 torch.Size([3, 4]) 相加，先将后者填充为 torch.Size([1, 2, 3, 4]) ，二者相加后 shape 为 [1, 2, 3, 4] torch.Size([3, 2, 1, 4]) 与 torch.Size([3, 4]) 相加，则先将两者填充为 torch.Size([3, 2, 3, 4]) ，二者相加后 shape 为 [3,
PyTorch-1.10(五)--torch数学运算
Hanscal
05-11 3649
目录 元素操作 归纳操作 比较操作 频谱操作 其他操作 BLAS和LAPACK操作 元素操作 abs 计算输入中每个元素的绝对值。 absolute torch.abs()别名 acos 计算输入中每个元素的反余弦。 arccos torch.acos()别名 acosh 计算输入元素的
关于pytorch中部分矩阵乘法的总结（torch.mm,torch.mul,torch.matmul）
12-21
在PyTorch中，处理矩阵乘法有三种主要的方法：`torch.mul`, `torch.mm`, 和 `torch.matmul`。每种方法都有其特定的用法和适用场景。 1. **torch.mul**: 这个函数执行元素级乘法，也就是说，它会将输入张量`input`的...
python torch.utils.data.DataLoader使用方法
09-17
`torch.utils.data.DataLoader`是PyTorch框架中用于高效加载和处理数据的关键组件。它在机器学习模型的训练过程中起着至关重要的作用，因为它的功能包括数据分批、数据预处理、多线程加载以及可选的随机打乱顺序等。...
PyTorch的torch.cat用法
09-16
PyTorch中的`torch.cat`函数是一个非常重要的操作，它用于将多个张量沿着指定的维度进行拼接。这个函数在构建复杂的神经网络模型，特别是在处理图像数据和序列数据时非常常用。下面我们将详细探讨`torch.cat`的使用...
pytorch loss 出现nan，原因之一，计算图中存在torch.sqrt或者 **0.5，以及如何解决
小欧欧的博客
11-11 8138
今天写一个loss函数 dist=torch.sqrt(x*x+y*y) loss=soomthL1loss(dist,gt_dist) 我随便写的几句示意代码，这样会导致在第一个iteration之后出现nan，第一次iteration之内，还是可以看到loss不为nan的。 解决办法： 1、不开方，因为开方的求导会出现在分母上，因此需要避免分母为0！ 2、tor...
torch 指数
Python领域优质萌新创作者
06-04 987
函数计算张量的指数。该函数将输入张量的每个元素都取指数。中进行指数和对数运算的灵活性和方便性，可以根据需要选择适合的函数来处理数据。如果输入张量的类型为整型，需要先将其转换为浮点型再进行指数运算。：计算输入张量的指数值减去1，即e的幂次方减去1。函数接受并处理浮点型张量，因此输入张量的类型应为。计算了每个元素的指数值，并返回一个新的张量。：计算输入张量的指数值，即e的幂次方。：计算输入张量的以10为底的对数。：计算输入张量的以2为底的对数。，其中包含了对应的指数值。：计算输入张量的自然对数。
pytorch中的矩阵乘法：函数mul,mm,mv以及 @运算 和 *运算
人工智能视觉分析算法学习实践和经验分享。
11-02 3万+
pytorch中矩阵运算种类 关于@运算，*运算，torch.mul(), torch.mm(), torch.mv(), tensor.t() @ 和 *代表矩阵的两种相乘方式：@表示常规的数学上定义的矩阵相乘；*表示两个矩阵对应位置处的两个元素相乘。 x.dot(y): 向量乘积,x，y均为一维向量。 *和torch.mul()等同:表示相同shape矩阵点乘，即对应位置相乘，得到矩阵有相同的shape。 @和torch.mm(a, b)等同：正常矩阵相乘，要求a的列数与b的行数相同。 torch.mv
pytorch学习笔记1：张量
weixin_44740082的博客
06-07 1466
目录 Tensor与numpy相互转换： torch.ones(),torch.add(),torch.zeros(),torch.squeeze() Tensor与numpy相互转换： import torch x=torch.Tensor(2,3)#生成一个4*5的Tensor张量 将Tensor转换为numpy数组 y=x.numpy() 将numpy数组转换为Tenso...
Torch学习笔记
whgyxy的博客
08-14 1万+
Torch笔记 （二）快速入门 Torch中的唯一的数据结构就是Tensor了，而该结构简洁而且强大，非常适合进行矩阵类的数值计算，它是Torch中最最重要的类了。这个Tensor其实就是个多维矩阵，支持矩阵的各种操作。这里需要特别强调的是，lua中的数组（其实是table）下标是从1开始的，因此Tensor对象的下标也是从1开始的。 咱们从程序猿的角度来说，首先，Tensor也是有类型的
torch.mul() 和 torch.mm() 的区别
热门推荐
Real_Brilliant的博客
01-04 9万+
torch.mul(a, b)是矩阵a和b对应位相乘，a和b的维度必须相等，比如a的维度是(1, 2)，b的维度是(1, 2)，返回的仍是(1, 2)的矩阵 torch.mm(a, b)是矩阵a和b矩阵相乘，比如a的维度是(1, 2)，b的维度是(2, 3)，返回的就是(1, 3)的矩阵 import torch a = torch.rand(1, 2) b = torch.rand(1, ......
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) – 第一个相乘矩...
torch.mm和torch.matmul
06-28
### 回答1： torch.mm和torch.matmul都是PyTorch中用于矩阵乘法的函数，但是它们的输入和输出有所不同。 torch.mm只能用于两个二维矩阵的乘法，即两个矩阵的维度分别为(m,n)和(n,p)，输出的矩阵维度为(m,p)。 而torch.matmul可以用于多个矩阵的乘法，且支持广播机制，即可以对不同维度的矩阵进行乘法。输入的矩阵可以是任意维度的张量，输出的矩阵维度也可以是任意维度的张量，但是要满足矩阵乘法的规则。 因此，torch.matmul比torch.mm更加灵活，可以处理更多的矩阵乘法情况。 ### 回答2： torch.mm和torch.matmul是在PyTorch中用于矩阵乘法运算的两个函数。 torch.mm函数的输入是两个二维张量，它计算它们的矩阵积，并返回一个二维张量作为输出。它的代码实现中，使用了BLAS（基本线性代数子程序）库中的矩阵乘法实现，能够利用底层CPU的多线程进行加速，因此在大规模矩阵计算时，torch.mm的速度明显快于非优化的for循环实现。 而torch.matmul函数则适用于多维张量之间的矩阵乘法。通常情况下，它的第一个输入张量需要是至少二维的，第二个输入张量可以是二维或者更高维度的，两个张量将按照向量积的规则进行广播。也就是说，如果第一个张量是形状为(m, n)的矩阵，第二个张量是(m, n, p)的张量，那么它们的矩阵乘积将得到一个形状为(m, p)的矩阵。值得注意的是，当输入张量维度超过二维的时候，torch.matmul函数不一定等价于torch.mm函数。 总的来说，torch.mm和torch.matmul是实现矩阵乘法计算的两个强大函数，torch.mm适用于计算两个二维张量的矩阵积，torch.matmul则适用于处理更高维度的多维张量之间的向量积。在实际使用时，需要根据具体任务需求来选择使用哪个函数。 ### 回答3： torch.mm和torch.matmul都是PyTorch中的矩阵乘法函数，可以用来进行矩阵乘法运算。但是，它们之间还是存在一些细微的差别的。 torch.mm是一个比较早的矩阵乘法函数，它的操作对象必须是两个二维矩阵。torch.mm函数相当于numpy中的dot函数，会将两个矩阵进行标准的矩阵乘法运算，输出结果也是一个二维矩阵。而且，torch.mm只能进行二维矩阵的乘法运算，如果其中有一个矩阵是三维矩阵，则会报错。 与torch.mm不同的是，torch.matmul可以进行任意维度的矩阵乘法运算。具体来说，它根据输入的两个矩阵的维度特性，自动选择最合适的矩阵乘法方式。这种方式既包括标准的矩阵乘法，也包括一些特殊情况下矩阵乘法的优化方式。此外，torch.matmul还支持广播机制，也就是说可以与高维的元素运算。 总的来说，torch.mm和torch.matmul都是PyTorch中的矩阵乘法函数，可以满足大部分的矩阵乘法求解需求，但是它们适用的场景有所不同。当输入数据都是二维矩阵的时候，建议使用torch.mm；而当需要进行任意维度的矩阵乘法时，或者需要支持广播操作时，则可以使用torch.matmul。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值