torch.matmul() 详解

已于 2023-06-20 13:07:00 修改
阅读量1.8k 收藏 7
点赞数 2
分类专栏： 经验及避坑分享 PyTorch笔记 文章标签： 深度学习 pytorch 人工智能
于 2023-06-20 12:57:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42426841/article/details/131304542
版权

最近在准备做 HW04，在读 transformer 的源码的时候发现 attention score 的 torch.matmul() 的奇妙设置，故有此篇文章进行分享。

前言碎碎念：

一开始我以为 torch.matmul 所做的工作就是简单的矩阵相乘，即：假设我们有两个矩阵 A 和 B，它们的 size 分别为 (m, n) 和 (n, p)，那么 A x B 的 size 为 (m, p)。然后我看了眼官方文档的例子：

tensor1 = torch.randn(10, 3, 4)
tensor2 = torch.randn(10, 4, 5)
torch.matmul(tensor1, tensor2).size()

>> torch.Size([10, 3, 5])

大大的问号冒了出来 : )，这也能乘？

文章的代码文件：notebook 代码

文章目录


下面结合官方文档提供一些例子给大家理解。

torch.matmul(input, other, ***, out=None) → Tensor

两个张量的矩阵乘积，具体行为取决于张量的维度，如下所示。

这里为了描述方便，用 input_d 和 other_d 分别指代 input.dim() 和 other.dim()，使用 torch.randint() 替代 torch.randn() 方便印证。

前期工作

import torch

# 固定 torch 的随机数种子，以便重现结果
torch.manual_seed(0)

# 打印信息
def print_info(A, B):
    print(f"A: {A}\nB: {B}")
    print(f"A 的维度: {A.dim()},\t B 的维度: {B.dim()}")
    print(f"A 的元素总数: {A.numel()},\t B 的元素总数: {B.numel()}")
    print(f"torch.matmul(A, B): {torch.matmul(A, B)}")
    print(f"torch.matmul(A, B).size(): {torch.matmul(A, B).size()}")

input_d = other_d = 1（两个 Tensor 皆为 1 维）

此时就是我们常说的点积（dot product），返回标量。注意，这里是维度为 1，而不是元素总数。

A = torch.randint(0, 5, size=(2,))
B = torch.randint(0, 5, size=(2,))

print_info(A, B)

>> A: tensor([4, 4])
>> B: tensor([3, 0])
>> A 的维度: 1,	 B 的维度: 1
>> A 的元素总数: 2,	 B 的元素总数: 2
>> torch.matmul(A, B) = 12
>> torch.matmul(A, B).size() = torch.Size([])

input_d = other_d = 2 （两个 Tensor 皆为 2 维）

返回矩阵乘积的结果。

A = torch.randint(0, 5, size=(2, 1))
B = torch.randint(0, 5, size=(1, 2))

print_info(A, B)

>> A: tensor([[3],
>>         [4]])
>> B: tensor([[2, 3]])
>> A 的维度: 2,	 B 的维度: 2
>> A 的元素总数: 2,	 B 的元素总数: 2
>> torch.matmul(A, B) = tensor([[ 6,  9],
>>         [ 8, 12]])
>> torch.matmul(A, B).size() = torch.Size([2, 2])

input_d = 1, other_d = 2

按照广播机制（boardcasting）进行处理，即：从 size 的尾部开始一一比对，如果维度不够，则扩展一维，令初始值为 1 再进行计算。计算完之后移除扩展的维度，用下面的例子来说就是扩展成 (1, 2) 后，(1, 2) * (2, 2) => (1, 2) => (2, )

A = torch.randint(0, 5, size=(2, ))
B = torch.randint(0, 5, size=(2, 2))

print_info(A, B)

>> A: tensor([2, 3])
>> B: tensor([[1, 1],
>>         [1, 4]])
>> A 的维度: 1,	 B 的维度: 2
>> A 的元素总数: 2,	 B 的元素总数: 4
>> torch.matmul(A, B) = tensor([ 5, 14])
>> torch.matmul(A, B).size() = torch.Size([2])

input_d = 2, other_d = 1

返回矩阵与向量的乘积。

# 这里使用上一次的矩阵和向量，方便对照
print_info(B, A)

>> A: tensor([[1, 1],
>>         [1, 4]])
>> B: tensor([2, 3])
>> A 的维度: 2,	 B 的维度: 1
>> A 的元素总数: 4,	 B 的元素总数: 2
>> torch.matmul(A, B) = tensor([ 5, 14])
>> torch.matmul(A, B).size() = torch.Size([2])

input_d > 2 or other_d > 2

以 input_d > 2 为例，维度不匹配就通过广播机制扩展，最后结果上删除掉扩展的维度。

个人理解：对于 dim >= 2 的 tensor 来说最后两维被看作矩阵的行和列，其余（如果存在）被看作 batch。

对于非矩阵（non-matrix）维度也是进行广播处理的，以 A.size() = (j, 1, m, n) 和 B.size() =(k, n, m) 为例，j x 1 和 k 是非矩阵维度，也就是 batch 维度，torch.matmul(A, B).size() = (j, k, m, m)。

input_d > 2 and other_d = 2

矩阵部分：(1, 2) * (2, 1)

A = torch.randint(0, 5, size=(2, 1, 2))
B = torch.randint(0, 5, size=(2, 1))

print_info(A, B)

>> A: tensor([[[3, 1]],
>> 
>>         [[1, 3]]])
>> B: tensor([[4],
>>         [3]])
>> A 的维度: 3,	 B 的维度: 2
>> A 的元素总数: 4,	 B 的元素总数: 2
>> torch.matmul(A, B) = tensor([[[15]],
>> 
>>         [[13]]])

input_d > 2 and other_d = 1

这里可以看成单拎出 A 的最后 2 维与 B 做 input_d = 2 和 other_d = 1 的乘法：(1, 2) * (2, )，具体细节可以回看上面对应的部分。

A = torch.randint(0, 5, size=(2, 1, 2))
B = torch.randint(0, 5, size=(2, ))

print_info(A, B)

>> A: tensor([[[1, 4]],
>> 
>>         [[1, 4]]])
>> B: tensor([4, 1])
>> A 的维度: 3,	 B 的维度: 1
>> A 的元素总数: 4,	 B 的元素总数: 2
>> torch.matmul(A, B) = tensor([[8],
>>         [8]])
>> torch.matmul(A, B).size() = torch.Size([2, 1])

input_d > 2 and other_d >2 （多维 Tensor）

广播部分：(2, 1, *, *) => (2, 2, *, *)。矩阵部分：(2, 1) * (1, 2)

A = torch.randint(0, 5, size=(2, 1, 2, 1))
B = torch.randint(0, 5, size=(2, 1, 2))

print_info(A, B)

>> A: tensor([[[[4],
>>           [4]]],
>> 
>> 
>>         [[[4],
>>           [0]]]])
>> B: tensor([[[1, 2]],
>> 
>>         [[3, 0]]])
>> A 的维度: 4,	 B 的维度: 3
>> A 的元素总数: 4,	 B 的元素总数: 4
>> torch.matmul(A, B) = tensor([[[[ 4,  8],
>>           [ 4,  8]],
>> 
>>          [[12,  0],
>>           [12,  0]]],
>> 
>> 
>>         [[[ 4,  8],
>>           [ 0,  0]],
>> 
>>          [[12,  0],
>>           [ 0,  0]]]])
>> torch.matmul(A, B).size() = torch.Size([2, 2, 2, 2])

在往下翻之前不妨思考一下 torch.matmul(B, A).size() 等于多少。

print_info(B, A)

>> A: tensor([[[1, 2]],
>> 
>>         [[3, 0]]])
>> B: tensor([[[[4],
>>           [4]]],
>> 
>> 
>>         [[[4],
>>           [0]]]])
>> A 的维度: 3,	 B 的维度: 4
>> A 的元素总数: 4,	 B 的元素总数: 4
>> torch.matmul(A, B) = tensor([[[[12]],
>> 
>>          [[12]]],
>> 
>> 
>>         [[[ 4]],
>> 
>>          [[12]]]])
>> torch.matmul(A, B).size() = torch.Size([2, 2, 1, 1])

拓展阅读

Broadcasting

torch.matmul的前后两个矩阵维度不同的小结
闲看庭前雪的博客
05-18 1910
系列文章目录 本系列记录自己的代码学习知识 torch.matmul的前后两个矩阵维度不同的小结系列文章目录前言一、torch.matmul()二、详解解释1.input维度比other大2.input维度比other小总结 前言 一、torch.matmul() torch.matmul()也是一种类似于矩阵相乘操作的tensor联乘操作。但是它可以利用python 中的广播机制，处理一些维度不同的tensor结构进行相乘操作。这也是该函数与torch.bmm()区别所在。 torch.matm
pytorch:torch.mm()和torch.matmul()的使用
12-23
如下所示： 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) – 第一个相乘矩阵 mat2 (Tensor) – 第二个相乘矩阵 out (Tensor, optional) – 输出张量 代码示例: import torch a=torch.randn(2,3) b=torch.randn(3,2)
【Pytorch】torch. matmul()
海到无边天作岸 山登绝顶我为峰
09-02 6875
Hello！ଘ(੭ˊᵕˋ)੭昵称：海轰标签：程序猿｜C++选手｜学生简介：因C语言结识编程，随后转入计算机专业，获得过国家奖学金，有幸在竞赛中拿过一些国奖、省奖…已保研学习经验：扎实基础 + 多做笔记 + 多敲代码 + 多思考 + 学好英语！唯有努力💪本文仅记录自己感兴趣的内容文章仅作为个人学习笔记记录，记录从0到1的一个过程希望对您有一点点帮助，如有错误欢迎小伙伴指正。
PyTorch学习之torch.matmul函数
qq_46396470的博客
07-01 856
用于两维或更高维张量的矩阵乘法操作。它支持广播机制，并且能够处理不同形状和维度的张量，适用于广泛的应用场景。
PyTorch疑难杂症（1）——torch.matmul()函数用法总结
Wendy的博客
11-05 5万+
目录一、函数介绍二、常见用法2.1 两个一维向量的乘积运算2.2 两个二维矩阵的乘积运算2.3 一个一维向量和一个二维矩阵的乘积运算2.4 一个二维矩阵和一个一维向量的乘积运算2.5 其他 一、函数介绍 pytorch中两个张量的乘法可以分为两种： 两个张量对应元素相乘，在PyTorch中可以通过torch.mul函数（或*运算符）实现； 两个张量矩阵相乘，在PyTorch中可以通过torch.matmul函数实现； torch.matmul(input, other) → Tensor 计算两个张量i
详解torch.dot()、torch.outer()、torch.mul()、torch.mm()和torch.matmul()等函数使用技巧
li1784506的博客
03-24 4912
torch.matmul()函数可以用于1维向量×1维向量，1维向量×2维矩阵，2维矩阵×1维向量，矩阵相乘等不同情况。现将相关案例进行介绍方便日后回顾。
class SelfAttention(nn.Module): def __init__(self, embed_dim): super(SelfAttention, self).__init__() self.embed_dim = embed_dim self.query = nn.Linear(embed_dim, embed_dim) self.key = nn.Linear(embed_dim, embed_dim) self.value = nn.Linear(embed_dim, embed_dim) def forward(self, x): q = self.query(x) k = self.key(x) v = self.value(x) attention_weights = F.softmax(torch.matmul(q, k.transpose(1, 2)) / torch.sqrt(torch.tensor(self.embed_dim)), dim=-1) output = torch.matmul(attention_weights, v) return output
03-09
scores = torch.matmul(q, k.transpose(-2, -1)) / (self.d_k ** 0.5) # (B, L, L) # 可选掩码机制 if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) # 归一化与输出 attn_weights = F...
详解torch.Tensor的4种乘法
09-16
本文将详细介绍`torch.Tensor`的四种乘法：`*`、`torch.mul`、`torch.mm`和`torch.matmul`。 1. `*` 运算符（点乘） 点乘通常用于元素级别的乘法，即对齐的张量元素逐个相乘。如果两个张量大小不一致，PyTorch会...
def synthetic_data(w, b, num_examples): #@save """生成y=Xw+b+噪声""" X = torch.normal(0, 1, (num_examples, len(w))) y = torch.matmul(X, w) + b y += torch.normal(0, 0.01, y.shape) return X, y.reshape((-1, 1)) true_w = torch.tensor([2, -3.4]) true_b = 4.2 features, labels = synthetic_data(true_w, true_b, 1000)
最新发布
03-11
接下来是y = torch.matmul(X, w) + b。这里计算的是矩阵乘法X乘以w向量，加上偏置b。不过这里需要注意，在PyTorch中，matmul处理的是张量的乘积，X的形状是(1000,2)，w是形状(2,)，所以矩阵乘法的结果是(1000,)的...
torch.matmul()用法介绍
热门推荐
杂文集
04-27 17万+
torch.mm()
关于pytorch中部分矩阵乘法的总结（torch.mm,torch.mul,torch.matmul）
12-21
一、torch.mul 该乘法可简单理解为矩阵各位相乘，一个常见的例子为向量点乘，源码定义为torch.mul（input,other,out=None）。其中other可以为一个数也可以为一个张量，other为数即张量的数乘。 该函数可触发广播机制（broadcast）。 tensor1 = 2*torch.ones(1,4) tensor2 = 3*torch.ones(4,1) print(torch.mul(tensor1, tensor2)) #输出结果为： tensor([[6., 6., 6., 6.], [6., 6., 6., 6.], [6.
torch.matmul
sinat_36099082的博客
01-14 329
import torch x = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8], [ 9, 10, 11, 12]], [[-1, -2, -3, -4], [-5, -6, -7, -8], [-9, -10, -11, -12]]]) y = torch.tensor([1,1,1]) print(x.size(), y.size()) print(torch.matm.
【Pytorch】进阶学习：基于矩阵乘法torch.matmul()实现全连接层
创作高质量博文，分享知识，共同进步！
03-08 2145
🚀【PyTorch进阶揭秘】掌握全连接层，轻松构建神经网络！🔥 本文带你深入探索PyTorch中全连接层的奥秘，从基本原理到实战演练，一应俱全！你将学会使用`torch.matmul()`实现全连接层，感受矩阵乘法的魅力。同时，我们还为你揭秘如何使用PyTorch的`nn.Linear`模块，让构建神经网络变得更加简单高效。此外，还有深度神经网络与全连接层的进阶学习等你来挑战！赶快加入我们，一起探索深度学习的无限可能吧！#PyTorch #全连接层 #神经网络 #深度学习 #实战演练
【Pytorch】进阶学习：实现矩阵乘法---torch.mul() 、 torch.mm() 和torch.matmul()的区别
m0_58477260的博客
04-15 2925
总结一下，torch.mm()和这三个函数的主要区别在于它们处理张量的方式和维度要求不同。执行的是元素级别的乘法，要求输入张量形状相同；torch.mm()执行的是标准的矩阵乘法，只适用于二维张量；而则提供了更广义的矩阵乘法，可以处理任意维度的张量，包括批量矩阵乘法。确保输入张量的形状符合函数的要求，否则可能会引发错误。对于矩阵乘法，需要注意矩阵的维度匹配问题，即第一个矩阵的列数必须等于第二个矩阵的行数。在进行批量矩阵乘法时，使用可以方便地处理多个矩阵的乘法运算。
PyTorch中的matmul函数详解
wzk4869的博客
11-19 1万+
PyTorch中的matmul函数详解
matmul torch 详解_pytorch 乘法运算汇总与解析
weixin_33870147的博客
12-24 397
pytorch 有多种乘法运算，在这里做一次全面的总结。元素一一相乘该操作又称作 "哈达玛积", 简单来说就是 tensor 元素逐个相乘。这个操作，是通过 也就是常规的乘号操作符定义的操作结果。torch.mul 是等价的。import torchdef element_by_element():x = torch.tensor([1, 2, 3])y = torch.tensor([4, 5,...
torch.matmul() 张量相乘
y4ung
04-14 6210
如果是二维的矩阵相乘，那就跟平时咱们做的矩阵乘法一样： a = torch.tensor([[1,2], [3,4]]) a Out[31]: tensor([[1, 2], [3, 4]]) b = torch.tensor([[2,2], [3,4]]) b Out[33]: tensor([[2, 2], [3, 4]]) torch.matmul(a, b) Out[34]: tensor([[ 8, 10],
class STFT(torch.nn.Module):类代码详解
05-24
`STFT` 是一个 PyTorch 模块，用于计算短时傅里叶变换（Short-Time Fourier Transform，STFT），是一种常用的信号处理技术。下面是这个模块的详细解释： ```python class STFT(torch.nn.Module): def __init__(self, filter_length=2048, hop_length=512, win_length=None, window='hann', center=True, pad_mode='reflect', freeze_parameters=True): super().__init__() self.filter_length = filter_length self.hop_length = hop_length self.center = center self.pad_mode = pad_mode if win_length is None: win_length = filter_length self.win_length = win_length self.window = get_window(window, win_length) # Create filter kernel fft_basis = np.fft.fft(np.eye(filter_length)) kernel = np.concatenate([np.real(fft_basis[:filter_length // 2 + 1, :]), np.imag(fft_basis[:filter_length // 2 + 1, :])], 0) self.register_buffer('kernel', torch.tensor(kernel, dtype=torch.float32)) # Freeze parameters if freeze_parameters: for name, param in self.named_parameters(): param.requires_grad = False def forward(self, waveform): assert (waveform.dim() == 1) # Pad waveform if self.center: waveform = nn.functional.pad(waveform.unsqueeze(0), (self.filter_length // 2, self.filter_length // 2), mode='constant', value=0) else: waveform = nn.functional.pad(waveform.unsqueeze(0), (self.filter_length - self.hop_length, 0), mode='constant', value=0) # Window waveform if waveform.shape[-1] < self.win_length: waveform = nn.functional.pad(waveform, (self.win_length - waveform.shape[-1], 0), mode='constant', value=0) waveform = waveform.squeeze(0) if self.window.device != waveform.device: self.window = self.window.to(waveform.device) windowed_waveform = waveform * self.window # Pad for linear convolution if self.center: windowed_waveform = nn.functional.pad(windowed_waveform, (self.filter_length // 2, self.filter_length // 2), mode='constant', value=0) else: windowed_waveform = nn.functional.pad(windowed_waveform, (self.filter_length - self.hop_length, 0), mode='constant', value=0) # Perform convolution fft = torch.fft.rfft(windowed_waveform.unsqueeze(0), dim=1) fft = torch.cat((fft.real, fft.imag), dim=1) output = torch.matmul(fft, self.kernel) # Remove redundant frequencies output = output[:, :self.filter_length // 2 + 1, :] return output ``` - `__init__` 方法：构造方法，用于初始化模块的各个参数。其中，`filter_length` 表示 STFT 的滤波器长度，`hop_length` 表示 STFT 的帧移（即相邻帧之间的采样点数），`win_length` 表示 STFT 的窗函数长度，`window` 是指定的窗函数类型（默认为汉宁窗），`center` 表示是否需要在信号两端填充 0 以保证 STFT 的中心位置与输入信号的中心位置对齐，`pad_mode` 是指定填充方式（默认为反射填充），`freeze_parameters` 表示是否需要冻结模块的参数。 - `forward` 方法：前向传播方法，用于计算输入信号的 STFT。其中，`waveform` 表示输入信号。首先，根据 `center` 和 `pad_mode` 对输入信号进行填充和窗函数处理，然后进行线性卷积，最后通过傅里叶变换计算 STFT。返回的 `output` 是一个张量，表示 STFT 系数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hoper.J

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值