pytorch中的各种乘法:mul,dot,mv,mm,matmul,*,@,enisum

概述

在PyTorch中,与乘法相关的操作可以覆盖从基本的标量乘法到更复杂的矩阵乘法等多种情况。下面是一些常用的乘法相关函数及其与数学中乘法概念的关联:

1. 标量乘法

  • 函数: .mul()* 操作符
  • 数学概念: 标量乘法,即一个数乘以另一个数。在PyTorch中,如果两个张量的形状兼容,它们可以进行元素级(element-wise)的乘法,这在数学中也可以看作是标量乘法的推广。
  • 示例:
    a = torch.tensor([1, 2, 3])
    b = 2
    result = a * b  # 或者 a.mul(b)
    

2. 向量乘法

  • 函数: .dot()
  • 数学概念: 向量点乘。两个向量的点乘是一个标量,等于对应元素相乘后的和。
  • 示例:
    a = torch.tensor([1, 2, 3])
    b = torch.tensor([4, 5, 6])
    result = torch.dot(a, b)
    

3. 矩阵与向量乘法

  • 函数: .mv()
  • 数学概念: 矩阵和向量相乘。如果有一个矩阵A和一个向量x,矩阵与向量的乘法结果是一个新的向量。
  • 示例:
    A = torch.tensor([[1, 2], [3, 4]])
    x = torch.tensor([1, 2])
    result = torch.mv(A, x)
    

4. 矩阵乘法

  • 函数: .mm()@ 操作符
  • 数学概念: 矩阵乘法。两个矩阵可以进行乘法运算,如果第一个矩阵的列数等于第二个矩阵的行数。
  • 示例:
    A = torch.tensor([[1, 2], [3, 4]])
    B = torch.tensor([[5, 6], [7, 8]])
    result = A.mm(B)  # 或者 A @ B
    

5. 批量矩阵乘法

  • 函数: .bmm()
  • 数学概念: 批量矩阵乘法。对两批矩阵进行乘法操作,每批中的矩阵独立相乘。
  • 示例:
    batch1 = torch.randn(10, 3, 4)
    batch2 = torch.randn(10, 4, 5)
    result = torch.bmm(batch1, batch2)
    

6. 广义矩阵乘法(Matmul)

  • 函数: .matmul()@ 操作符
  • 数学概念: 广义的矩阵乘法,可以处理标量、向量、矩阵和多维张量的乘法。其行为依据参与运算的张量的维度而定。
  • 示例:
    # 向量和向量
    a = torch.tensor([1, 2, 3])
    b = torch.tensor([4, 5, 6])
    result = torch.matmul(a, b)
    
    # 矩阵和矩阵
    A = torch.tensor([[1, 2], [3, 4]])
    B = torch.tensor([[5, 6], [7, 8]])
    result = torch.matmul(A, B)
    

在使用这些函数时,重要的是要理解它们各自的数学背景和适用场景,以选择最合适的操作完成你的任务。

torch.mul()详解

torch.mul()函数在PyTorch中用于执行元素级(element-wise)的乘法操作。这意味着两个张量的对应元素会相乘。torch.mul()可以用于标量乘法,也可以用于两个张量的元素级乘法。以下是一些使用torch.mul()的具体示例和说明:

1. 标量与张量的乘法

当与一个标量相乘时,torch.mul()会将这个标量乘以输入张量的每个元素。

import torch

# 创建一个张量
a = torch.tensor([1, 2, 3])

# 使用标量进行乘法
result = torch.mul(a, 2)

print(result)  # 输出: tensor([2, 4, 6])

2. 两个张量的元素级乘法

torch.mul()用于两个形状相同的张量时,它会将这两个张量的对应元素相乘。

import torch

# 创建两个张量
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

# 执行元素级乘法
result = torch.mul(a, b)

print(result)  # 输出: tensor([ 4, 10, 18])

3. 广播机制

torch.mul()也支持广播机制。如果两个张量的形状不完全相同,PyTorch会尝试自动扩展它们的形状使其匹配(只有当形状兼容时才会这样做)。

import torch

# 创建一个张量和一个形状不同的张量
a = torch.tensor([[1, 2, 3], [4, 5, 6]])
b = torch.tensor([2, 0, 1])

# 执行元素级乘法,b会自动扩展以匹配a的形状
result = torch.mul(a, b)

print(result)
# 输出:
# tensor([[2, 0, 3],
#         [8, 0, 6]])

在这个例子中,b被自动扩展(广播)到与a相同的形状,然后再进行元素级乘法。

注意事项

  • 当使用torch.mul()进行张量操作时,确保操作的张量要么形状完全相同,要么是可以广播的。
  • torch.mul()是元素级乘法,不是矩阵乘法。对于矩阵乘法,应使用torch.mm()torch.matmul()
  • torch.mul()也可以通过*操作符直接在张量之间使用,效果相同。

torch.mul()是PyTorch中进行元素级乘法的基础且强大的函数,适用于多种乘法操作场景。

torch.dot()详解

torch.dot()函数在PyTorch中用于计算两个一维张量的点积(也称为内积或数量积)。点积的结果是一个标量(即一个单一数值),它是两个输入向量对应元素乘积的总和。使用torch.dot()时,需要确保两个输入张量都是一维的,并且它们的长度相同。

基本用法

以下是torch.dot()的基本用法示例:

import torch

# 创建两个一维张量
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

# 计算点积
result = torch.dot(a, b)

print(result)  # 输出: tensor(32)

在这个例子中,ab的点积计算如下:

1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

因此,torch.dot(a, b)的结果是32

注意事项

  1. 输入限制torch.dot()只适用于一维张量。如果尝试对多维张量使用torch.dot(),将会引发错误。

  2. 长度匹配:参与点积的两个张量必须具有相同的长度。

  3. 多维张量的点积:如果需要计算多维张量的点积,可以先使用torch.flatten()torch.reshape()将张量转换为一维,然后再使用torch.dot()。或者,更常见的是使用torch.matmul()@操作符来计算多维张量的乘法或点积。

示例:多维张量的处理

如果你有多维张量并希望计算它们的点积,你需要先将它们转换为一维张量。这里是一个如何处理这种情况的示例:

import torch

# 创建两个二维张量
a = torch.tensor([[1, 2, 3]])
b = torch.tensor([[4], [5], [6]])

# 将二维张量转换为一维张量
a_flat = a.flatten()
b_flat = b.flatten()

# 计算转换后的一维张量的点积
result = torch.dot(a_flat, b_flat)

print(result)  # 输出: tensor(32)

在这个例子中,我们首先使用flatten()方法将两个二维张量ab转换为一维张量,然后计算它们的点积。

总之,torch.dot()是一个用于计算两个一维张量的点积的函数,它是实现向量点积运算的基本工具。对于更复杂的矩阵运算或多维张量,你可能需要使用torch.matmul()或其他相关函数。

torch.mm()详解

torch.mm()函数在PyTorch中用于执行两个二维矩阵的矩阵乘法。这个函数要求两个输入矩阵的维度是匹配的,即第一个矩阵的列数必须等于第二个矩阵的行数。

基本用法

下面是一个torch.mm()的基本使用示例:

import torch

# 创建两个二维矩阵
matrix1 = torch.tensor([[1, 2], [3, 4]])
matrix2 = torch.tensor([[5, 6], [7, 8]])

# 使用 torch.mm() 进行矩阵乘法
result = torch.mm(matrix1, matrix2)

print(result)

在这个例子中,matrix1是一个2x2的矩阵,matrix2也是一个2x2的矩阵。torch.mm()函数将这两个矩阵相乘,产生另一个2x2的矩阵。

注意事项

  1. 维度匹配:如果第一个矩阵是m x n的,第二个矩阵必须是n x p的,这样才能进行矩阵乘法,结果矩阵的大小将是m x p

  2. 不支持广播torch.mm()不支持广播,如果矩阵维度不匹配,将会抛出错误。

  3. 不适用于一维张量:如果输入是一维张量,torch.mm()将无法执行,因为它期望二维张量作为输入。对于一维张量,应使用torch.dot()torch.matmul()

  4. 多维张量:如果你需要处理多维张量的乘法,应该使用torch.matmul(),它支持广播和更高维度的张量乘法。

示例:不匹配维度的处理

如果你尝试使用不匹配维度的矩阵进行乘法,你会得到一个错误。以下是一个示例:

import torch

# 创建两个二维矩阵,但它们的维度不匹配
matrix1 = torch.tensor([[1, 2], [3, 4]])
matrix2 = torch.tensor([[5, 6]])

# 尝试使用 torch.mm() 进行矩阵乘法将抛出错误
# result = torch.mm(matrix1, matrix2)  # 这将抛出错误

# 正确的做法是确保维度匹配
matrix2 = torch.tensor([[5], [6]])
result = torch.mm(matrix1, matrix2)

print(result)  # 输出: tensor([[17], [39]])

在这个例子中,我们首先尝试使用两个不匹配维度的矩阵进行乘法,这会导致错误。然后我们通过调整matrix2的形状使其成为一个2x1的矩阵,这样它的行数就与matrix1的列数匹配,可以成功进行矩阵乘法。

torch.mm()是进行矩阵乘法的基础函数,适用于二维张量。对于更复杂的场景,包括需要广播的矩阵乘法,可以使用torch.matmul()@操作符。

torch.matmul()详解

torch.matmul() 是 PyTorch 中用于矩阵乘法的函数,它支持多维张量相乘,并且当涉及到二维张量时,它的行为与矩阵乘法相同。当处理更高维的张量时,它会应用广播规则。

以下是 torch.matmul() 的一些常见用法:

1. 两个向量相乘

如果两个张量都是一维的,torch.matmul() 返回的是它们的点积。

# 向量点积
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
c = torch.matmul(a, b)
# c = 1*4 + 2*5 + 3*6

2. 矩阵与向量相乘

如果第一个张量是二维的,第二个张量是一维的,torch.matmul() 会执行矩阵-向量乘法。

# 矩阵和向量相乘
A = torch.tensor([[1, 2], [3, 4]])
x = torch.tensor([5, 6])
y = torch.matmul(A, x)
# y 结果是 [17, 39],因为:
# [1*5 + 2*6, 3*5 + 4*6]

3. 两个矩阵相乘

如果两个张量都是二维的,torch.matmul() 执行的是矩阵乘法。

# 矩阵乘法
A = torch.tensor([[1, 2], [3, 4]])
B = torch.tensor([[5, 6], [7, 8]])
C = torch.matmul(A, B)
# C 结果是 [[19, 22], [43, 50]]

4. 批量矩阵乘法

当处理的张量是三维或更高维时,torch.matmul() 会执行批量矩阵乘法。

# 批量矩阵乘法
A = torch.randn(3, 2, 5)
B = torch.randn(3, 5, 3)
C = torch.matmul(A, B)  # 结果张量的大小为 (3, 2, 3)

在这个例子中,每个 2x5 的矩阵(A 张量中的)都与对应的 5x3 的矩阵(B 张量中的)相乘,得到一个 2x3 的矩阵,最终 C 张量的大小为 (3, 2, 3),其中有 3 个这样的矩阵。

5. 高维张量乘法和广播

torch.matmul() 也支持高维张量的乘法,并且会自动应用广播规则。

# 高维张量乘法
A = torch.randn(2, 3, 4, 5)
B = torch.randn(2, 3, 5, 6)
C = torch.matmul(A, B)  # 结果张量的大小为 (2, 3, 4, 6)

在这个例子中,最后两个维度(4x5 和 5x6)被用于矩阵相乘,而其他维度(2x3)则是批量大小。

使用注意事项

  • 当处理的张量维度不同时,torch.matmul() 会尝试广播它们以匹配维度。如果张量无法广播,则会抛出错误。
  • torch.matmul() 不会修改输入张量,它会返回一个新的张量。

总之,torch.matmul() 是一个非常强大的函数,它可以处理从简单的向量点积到复杂的批量矩阵乘法的各种场景。在深度学习中,这个函数经常被用来实现各种线性变换,包括全连接层、卷积层的展开操作、循环神经网络中的状态更新等。

torch.einsum()

torch.einsum 是一个非常强大和灵活的函数,它允许用户通过指定一个表示运算的字符串表达式来执行复杂的张量运算。这个表达式定义了输入张量的维度如何参与运算并生成输出张量。einsum 的名称来源于爱因斯坦求和约定(Einstein summation convention),这是一种省略显式求和符号的数学表示方法,非常适合描述多维数组(张量)的运算。

基本语法

torch.einsum 的基本语法如下:

torch.einsum(equation, *operands)
  • equation: 一个描述输入张量维度和运算的字符串。
  • operands: 需要参与运算的张量。

表达式解析

equation 字符串由两部分组成,分别是输入部分和输出部分,它们通过 -> 分隔。如果省略输出部分,torch.einsum 会根据输入部分推断输出维度。

  • 字母(如 i, j, k 等)用于表示张量的不同维度。
  • 相同的字母在不同输入张量中出现表示这些维度将进行求和。
  • 不同的字母表示不同的维度,它们的顺序决定了输出张量的维度顺序。
  • 如果某个字母只在输出部分出现,表示对应维度进行广播。

示例

下面通过几个示例来详细解释 torch.einsum 的用法:

示例 1: 向量点积
import torch

a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

# 计算向量点积
result = torch.einsum('i,i->', a, b)
print(result)  # 输出: tensor(32)

这里 'i,i->' 表示两个输入向量的对应元素相乘后求和,因为输出部分为空,表示结果是一个标量。

示例 2: 矩阵乘法
a = torch.tensor([[1, 2], [3, 4]])
b = torch.tensor([[5, 6], [7, 8]])

# 计算矩阵乘法
result = torch.einsum('ij,jk->ik', a, b)
print(result)

这里 'ij,jk->ik' 表示第一个矩阵的行与第二个矩阵的列相乘,并对中间维度 j 求和,得到结果矩阵。

示例 3: 转置
a = torch.tensor([[1, 2], [3, 4]])

# 计算转置
result = torch.einsum('ij->ji', a)
print(result)

这里 'ij->ji' 表示将输入矩阵的行和列互换,即进行转置。

示例 4: 批量矩阵乘法
a = torch.randn(3, 2, 5)
b = torch.randn(3, 5, 4)

# 批量矩阵乘法
result = torch.einsum('bik,bkj->bij', a, b)
print(result.shape)  # 输出: torch.Size([3, 2, 4])

这里 'bik,bkj->bij' 表示对每个批次的矩阵进行矩阵乘法,b 维度表示批次大小,它在输出中保留。

总结

torch.einsum 提供了一种非常灵活的方式来描述和执行多维张量之间的复杂运算。通过掌握爱因斯坦求和约定,你可以构建几乎任何类型的张量运算,从而在深度学习和科学计算中发挥重要作用。

汇总

下面是一个关于 PyTorch 中常见乘法函数的表格,包括它们的函数名称、用途、计算对象、输入和输出维度,以及是否支持广播机制的信息。这个表格以 Markdown 格式呈现:

函数名称用途计算对象输入维度输出维度支持广播机制
torch.mul逐元素乘法张量与张量相同或兼容维度与输入维度相同
torch.mm矩阵乘法二维张量(m \times n), (n \times p)(m \times p)
torch.matmul张量乘法张量可变取决于输入
torch.bmm批量矩阵乘法三维张量(b \times m \times n), (b \times n \times p)(b \times m \times p)
torch.einsum自定义乘法和求和张量取决于表达式取决于表达式

说明

  • 逐元素乘法 (torch.mul): 对两个张量的对应元素进行乘法操作。如果两个张量的维度不一致,将使用广播机制来匹配它们的形状。

  • 矩阵乘法 (torch.mm): 仅限于处理二维张量(矩阵)。它按照矩阵乘法的规则来计算结果,不支持广播。

  • 张量乘法 (torch.matmul): 更通用的乘法函数,可以处理高维张量。对于二维张量,它等价于 torch.mm。对于高维张量,它执行批量矩阵乘法。

  • 批量矩阵乘法 (torch.bmm): 专门用于三维张量的矩阵乘法,其中第一维被视为批次大小。它不支持广播。

  • 自定义乘法和求和 (torch.einsum): 提供了一种灵活的方式来指定操作,包括乘法、求和等。它通过一个特定的字符串表达式来定义操作,非常灵活,支持广播。

这个表格提供了 PyTorch 中不同乘法操作的快速参考,帮助你根据具体的需求选择合适的函数。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值