torch.bmm()函数解读

已于 2022-05-04 19:50:24 修改
阅读量10w+ 收藏 240
点赞数 93
文章标签： pytorch 深度学习 python
于 2019-09-02 16:14:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40178291/article/details/100302375
版权
本文详细解析了PyTorch中torch.bmm函数的使用方法，该函数用于计算两个三维张量的批量矩阵乘法。通过示例展示了如何进行正确的维度匹配，并避免常见的运行错误。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

函数作用
计算两个tensor的矩阵乘法，torch.bmm(a,b),tensor a 的size为(b,h,w),tensor b的size为(b,w,m) 也就是说两个tensor的第一维是相等的，然后第一个数组的第三维和第二个数组的第二维度要求一样，对于剩下的则不做要求，输出维度 （b,h,m）
代码示例

>>> c=torch.randn((2,5))
>>> print(c)
tensor([[ 1.0559, -0.3533,  0.5194,  0.9526, -0.2483],
        [-0.1293,  0.4809, -0.5268, -0.3673,  0.0666]])
>>> d=torch.reshape(c,(5,2))
>>> print(d)
tensor([[ 1.0559, -0.3533],
        [ 0.5194,  0.9526],
        [-0.2483, -0.1293],
        [ 0.4809, -0.5268],
        [-0.3673,  0.0666]])
>>> e=torch.bmm(c,d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: Dimension out of range (expected to be in range of [-2, 1], but got 2)

当tensor维度为2时会报错！

>>> ccc=torch.randn((1,2,2,5))
>>> ddd=torch.randn((1,2,5,2))
>>> e=torch.bmm(ccc,ddd)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: invalid argument 1: expected 3D tensor, got 4D at /opt/conda/conda-bld/pytorch_1535490206202/work/aten/src/TH/generic/THTensorMath.cpp:2304

维度为4时也会报错！

>>> cc=torch.randn((2,2,5))
>>>print(cc)
tensor([[[ 1.4873, -0.7482, -0.6734, -0.9682,  1.2869],
         [ 0.0550, -0.4461, -0.1102, -0.0797, -0.8349]],
         [[-0.6872,  1.1920, -0.9732,  0.4580,  0.7901],
         [ 0.3035,  0.2022,  0.8815,  0.9982, -1.1892]]])
>>>dd=torch.reshape(cc,(2,5,2))
>>> print(dd)
tensor([[[ 1.4873, -0.7482],
         [-0.6734, -0.9682],
         [ 1.2869,  0.0550],
         [-0.4461, -0.1102],
         [-0.0797, -0.8349]],
         [[-0.6872,  1.1920],
         [-0.9732,  0.4580],
         [ 0.7901,  0.3035],
         [ 0.2022,  0.8815],
         [ 0.9982, -1.1892]]])
>>>e=torch.bmm(cc,dd)
>>> print(e)
tensor([[[ 2.1787, -1.3931],
         [ 0.3425,  1.0906]],
         [[-0.5754, -1.1045],
         [-0.6941,  3.0161]]])
 >>> e.size()
torch.Size([2, 2, 2])

正确！

wang xiang
关注
代码解读：详细解读Diffusion ID保持生成经典工作InstantID
沉迷单车的追风少年
04-14 134
InstantID是ID保持生成的经典工作，后续大量图片/视频ID保持的工作都是基于这个工作完成的。这篇博客从代码出发，并结合原理，详细解读一下InstantID的代码。
【pytorch】torch.mm，torch.bmm以及torch.matmul的使用
热门推荐
安安爸Chris的专栏
08-19 3万+
torch.mm torch.mm是两个矩阵相乘，即两个二维的张量相乘 如下面的例子 mat1 = torch.randn(2,3) print("mat1=", mat1) mat2 = torch.randn(3,2) print("mat2=", mat2) mat3 = torch.mm(mat1, mat2) print("mat3=", mat3) 但是如果维度超过二维，则会报错。RuntimeError: self must be a matrix torch.bmm 它其实就是加了一
pytorch.unsqueeze及bmm函数
NewDreamstyle的博客
06-28 1638
2019-06-28晚 cs224n-winter2019-assignment4 用pytorch实现seq2seq-attention NMT Model(神经机器翻译模型) unsqueeze a = torch.randn(5,4) for i in range(-3,3): b = torch.unsqueeze(a,dim=i) print('{} _th size:{...
【数据结构】List介绍
小黑屋的黑小子的博客
03-12 776
List中提供了好的方法，具体如下：虽然方法比较多，但是常用方法如下方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素删除遇到的第一个 o获取下标 index 位置元素将下标 index 位置元素设置为 element清空判断 o 是否在线性表中返回第一个 o 所在下标返回最后一个 o 的下标截取部分 list。
torch.bmm()
weixin_44012667的博客
07-11 818
是 PyTorch 中用于批量矩阵乘法的函数。全称是 batch matrix-matrix product，用于对一批矩阵进行乘法运算。
torch.bmm函数讲解
2303_77480410的博客
10-01 6648
例如，假设我们有两个批次的矩阵 A 和 B，维度分别为 (2, 3, 4) 和 (2, 4, 5)。我们可以使用 torch.bmm 将它们相乘。torch.bmm 是 PyTorch 中的一个函数，用于执行批矩阵乘法（batch matrix multiplication）操作。torch.bmm 将批中的每对矩阵相乘，返回一个新的三维张量，形状为 (batch_size, n, p)。其中 n 是第一个矩阵的列数，m 是两个矩阵共享的维度，p 是第二个矩阵的列数。
Sub-center ArcFace
weixin_37958272的博客
08-19 3864
Sub-center ArcFace: Boosting Face Recognition by Large-scale NoisyWeb Faces Margin-based的深度人脸识别方法（如SphereFace、CosFace和ArcFace）在无约束的人脸识别中取得了显著的成功。然而，这些方法容易受到训练数据中大量标签噪声的影响，因此需要费力的人力来清理数据集。在本文中，我们放宽了ArcFace的类内约束，以提高对标签噪声的鲁棒性。更具体地说，我们为每个类设计了K个子中心，训练样本只需要接近K个正
卷积神经网络（CNN）中常见的函数方法
yuyu_297的博客
06-01 1366
是 PyTorch 中用于的方法。它返回一个新的张量，与原张量共享数据，但形状不同。通常用来对特征进行展平操作。功能类似于 NumPy 中的reshape()方法。new_shape是一个元组或一个张量，用于指定新张量的形状。其中的每个维度可以是具体的大小，也可以是-1，表示根据其他维度的大小自动推断该维度的大小。
AF3 rot_matmul 和 rot_vec_mul函数解读
最新发布
qq_27390023的博客
03-22 1004
AlphaFold3  rigid_utils 模块的 rot_matmul 和 rot_vec_mul 函数实现了手动计算两个旋转矩阵的乘法 A×B 以及矩阵-向量乘法 R×t， 避免了直接用矩阵乘法的AMP（Automatic Mixed Precision）问题。
Transformer源代码解释之PyTorch篇
Paper weekly
07-05 2415
©PaperWeekly 原创 ·作者|Sherlock学校|苏州科技大学本科生研究方向|自然语言处理词嵌入Transformer 本质上是一种 Encoder，以翻译任务为...
torch.bmm 函数
weixin_56915683的博客
05-31 3529
torch.bmm 函数 这里只是记录一下，为了以后个人方便查找。 具体参考：pytorch官方文档 torch.bmm(input, mat2, *, deterministic=False, out=None) → Tensor 功能：对 input 和 mat2 矩阵执行批处理矩阵积。 input 和 mat2 必须是三维张量，每个张量包含相同数量的矩阵。 输入： input tensor 维度：(b×n×m) ； mat2 tensor 维度： (b×m×p) , 输出： out te
torch.bmm() torch.matmul() expand() cat() split()
marmalade要天天向上
10-20 427
torch.bmm torch.bmm(batch1, batch2, out=None) → Tensor 对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作。batch1和 batch2都为包含相同数量矩阵的3维张量。 如果batch1是形为b×n×m的张量，batch1是形为b×m×p的张量，则out和mat的形状都是n×p(n×m m×p ->n×p)，即 res=(b...
Pytorch: torch.bmm()批量矩阵运算
Ethan_Rich的博客
12-28 1228
torch.bmm函数是 PyTorch 中用于执行批量矩阵乘法（Batch Matrix-Matrix Multiplication）的函数。它的名字 "bmm" 表示 "batch matrix multiplication"。注意：torch.bmm()是不带广播机制的，也就说需按照矩阵运算机制。比如:[B,3,4]*[B,4,5]是可以的，而[B,3,2]*[B,8,5]是不可以的。
【PyTorch】torch.bmm() 函数：批量矩阵乘法
彬彬侠的博客
02-10 624
torch.bmm（batch matrix multiplication）是PyTorch中用于进行批量矩阵乘法的函数。该函数的作用是对多个矩阵进行批量乘法，它接受两个三维张量作为输入，返回一个三维张量，其中每个二维矩阵是两个输入张量中相应矩阵的乘积。在深度学习中，torch.bmm广泛应用于模型训练、卷积操作和时间序列处理等任务。
torch.bmm()函数的使用
qq_43391414的博客
12-01 8373
torch.bmm()的使用： a=torch.Tensor([[[3,4],[1,2]],[[3,4],[1,2]],[[3,4],[1,2]]]) b=torch.Tensor([[[1,2],[3,4]],[[1,2],[3,4]],[[3,4],[1,2]]]) print(a.shape) print(b.shape) 我们学过矩阵乘法知道，矩阵a,b是不可以相乘的，但是其实这两个矩阵a,b特殊，因为他们第一维是相同的，都是3，剩下两维22，22不就可以相乘了吗？因此就有了这个函数。这个函数所
Pytorch中张量矩阵乘法函数(mm, bmm, matmul)使用说明，含高维张量实例及运行结果
qq_39407949的博客
09-14 1万+
input(Tensor) – – 第一个要相乘的矩阵** mat2* (Tensor) – – 第二个要相乘的矩阵不支持广播到通用形状、类型推广以及整数、浮点和复杂输入。input(Tensor) – – 第一批要相乘的矩阵** mat2* (Tensor) – – 第二批要相乘的矩阵不支持广播到通用形状、类型推广以及整数、浮点和复杂输入。input(Tensor) – – 第一个要相乘的张量** mat2* (Tensor) – – 第二个要相乘的张量支持。
torch.bmm
qq_41289353的博客
03-21 373
torch.bmm(input, mat2, *, out=None) → Tensor 如果input是（b*n*m）的tensor，mat2是（b*m*p）的tensor，那么output是（b*n*p）的tensor out = input * mat2 输入(Tensor) – 第一批要相乘的矩阵 mat2(Tensor) – 第二批要相乘的矩阵 out(Tensor,optional) – 输出张量。 input = tor...
Transformer代码完全解读
10-13
Transformer是一种基于自注意力机制的神经网络模型，广泛应用于自然语言处理任务中，如机器翻译、文本生成等。下面是Transformer的代码解读： 首先，我们需要导入必要的库和模块： ```python import torch import torch.nn as nn import torch.nn.functional as F ``` 接着，我们定义了一个叫做PositionalEncoding的类，用于对输入的序列进行位置编码。位置编码的目的是为了让模型能够感知输入序列中每个元素的位置信息，从而更好地处理序列中的长距离依赖关系。 ```python class PositionalEncoding(nn.Module): def __init__(self, d_model, dropout=0.1, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0).transpose(0, 1) self.register_buffer('pe', pe) def forward(self, x): x = x + self.pe[:x.size(0), :] return self.dropout(x) ``` 在这个类中，我们首先定义了一个构造函数，其中d_model表示输入序列的维度，dropout表示dropout的概率，max_len表示输入序列的最大长度。在构造函数中，我们首先调用了父类的构造函数，然后定义了一个dropout层。 接着，我们创建了一个max_len x d_model的矩阵pe，并对其进行位置编码。具体来说，我们首先创建了一个长度为max_len的位置向量position，然后对每个位置向量应用一组不同的正弦和余弦函数，得到一个d_model维的位置编码向量。最后，我们将所有位置编码向量拼接成一个矩阵，并将其转置，以便与输入序列进行相加。 在forward函数中，我们将输入序列x与位置编码矩阵相加，并对结果进行dropout操作。 接下来，我们定义了一个叫做MultiHeadAttention的类，用于实现多头注意力机制。多头注意力机制是指将输入序列分别映射到多个不同的子空间中，并在每个子空间中计算注意力分数，最后将所有子空间的注意力分数加权求和得到最终的输出。 ```python class MultiHeadAttention(nn.Module): def __init__(self, d_model, nhead, dropout=0.1): super(MultiHeadAttention, self).__init__() self.nhead = nhead self.d_model = d_model self.head_dim = d_model // nhead self.qkv_proj = nn.Linear(d_model, 3 * d_model) self.out_proj = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(p=dropout) def forward(self, query, key, value, attn_mask=None): batch_size = query.size(0) qkv = self.qkv_proj(query).chunk(3, dim=-1) q, k, v = qkv[0], qkv[1], qkv[2] q = q.view(batch_size * self.nhead, -1, self.head_dim).transpose(0, 1) k = k.view(batch_size * self.nhead, -1, self.head_dim).transpose(0, 1) v = v.view(batch_size * self.nhead, -1, self.head_dim).transpose(0, 1) attn_scores = torch.bmm(q, k.transpose(1, 2)) attn_scores = attn_scores / math.sqrt(self.head_dim) if attn_mask is not None: attn_scores = attn_scores.masked_fill(attn_mask == 0, -1e9) attn_probs = F.softmax(attn_scores, dim=-1) attn_probs = self.dropout(attn_probs) attn_output = torch.bmm(attn_probs, v) attn_output = attn_output.transpose(0, 1).contiguous().view(batch_size, -1, self.d_model) attn_output = self.out_proj(attn_output) attn_output = self.dropout(attn_output) return attn_output ``` 在这个类中，我们首先定义了一个构造函数，其中d_model表示输入序列的维度，nhead表示头的数量，dropout表示dropout的概率。在构造函数中，我们首先调用了父类的构造函数，然后定义了一个线性层qkv_proj，用于将输入序列映射到三个不同的子空间中。接着，我们定义了一个线性层out_proj，用于将多头注意力机制的输出映射回原始的输入维度。最后，我们定义了一个dropout层。 在forward函数中，我们首先获取输入序列的batch_size，并将输入序列通过线性层qkv_proj映射到三个不同的子空间中。然后，我们将每个子空间的向量分别重塑为(batch_size * nhead, seq_len, head_dim)的形状，并将其转置，以便进行矩阵乘法。接着，我们计算每个位置之间的注意力分数，并对其进行缩放。如果存在attn_mask，则将其应用于注意力分数。然后，我们对注意力分数进行softmax操作，并对结果进行dropout。接着，我们将注意力分数与value矩阵相乘，并将结果重塑为(batch_size, seq_len, d_model)的形状。最后，我们将输出通过线性层out_proj映射回原始的输入维度，并对结果进行dropout。 最后，我们定义了一个叫做TransformerEncoderLayer的类，用于实现Transformer的编码器层。编码器层由两个子层组成：多头自注意力机制和前馈神经网络。 ```python class TransformerEncoderLayer(nn.Module): def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1): super(TransformerEncoderLayer, self).__init__() self.self_attn = MultiHeadAttention(d_model, nhead, dropout=dropout) self.linear1 = nn.Linear(d_model, dim_feedforward) self.dropout = nn.Dropout(p=dropout) self.linear2 = nn.Linear(dim_feedforward, d_model) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) def forward(self, src, src_mask=None): src2 = self.self_attn(src, src, src, attn_mask=src_mask) src = src + self.dropout(src2) src = self.norm1(src) src2 = self.linear2(self.dropout(F.relu(self.linear1(src)))) src = src + self.dropout(src2) src = self.norm2(src) return src ``` 在这个类中，我们首先定义了一个构造函数，其中d_model表示输入序列的维度，nhead表示头的数量，dim_feedforward表示前馈神经网络的隐藏层维度，dropout表示dropout的概率。在构造函数中，我们定义了一个多头自注意力机制self_attn，一个线性层linear1，一个dropout层，一个线性层linear2，以及两个LayerNorm层。 在forward函数中，我们首先使用多头自注意力机制self_attn对输入序列进行编码，并将结果与原始输入序列相加。然后，我们对结果进行归一化，并通过一个前馈神经网络进行非线性变换。最后，我们再次将结果与原始输入序列相加，并对结果进行归一化。
评论 32
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值