torch.einsum详解

已于 2022-06-30 10:31:27 修改
阅读量7.7k 收藏 4
点赞数 2
分类专栏： python 文章标签： pytorch 深度学习
于 2022-06-05 10:14:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mytzs123/article/details/125126430
版权
本文通过实例详细解析了 PyTorch 中的 `einsum` 函数，展示了如何使用它进行矩阵乘法操作。通过权重张量与输入张量的对应元素相乘，得到不同形状的输出张量，深入理解了 `einsum` 的灵活性和威力。
摘要由CSDN通过智能技术生成

 举例：

vector = torch.tensor([[1,2,3,4,5],[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1]])
a = vector[0, :]
weight = torch.arange(225).view(5, 5, 3, 3)
out = torch.einsum('oihw,o->oihw', weight, vector[0,:])
print(out)
# 等于在两个 O 维度上矩阵相乘

weight:
tensor([[[[  0,   1,   2],
          [  3,   4,   5],
          [  6,   7,   8]],

         [[  9,  10,  11],
          [ 12,  13,  14],
          [ 15,  16,  17]],

         [[ 18,  19,  20],
          [ 21,  22,  23],
          [ 24,  25,  26]],

         [[ 27,  28,  29],
          [ 30,  31,  32],
          [ 33,  34,  35]],

         [[ 36,  37,  38],
          [ 39,  40,  41],
          [ 42,  43,  44]]],


        [[[ 45,  46,  47],
          [ 48,  49,  50],
          [ 51,  52,  53]],

         [[ 54,  55,  56],
          [ 57,  58,  59],
          [ 60,  61,  62]],

         [[ 63,  64,  65],
          [ 66,  67,  68],
          [ 69,  70,  71]],

         [[ 72,  73,  74],
          [ 75,  76,  77],
          [ 78,  79,  80]],

         [[ 81,  82,  83],
          [ 84,  85,  86],
          [ 87,  88,  89]]],


        [[[ 90,  91,  92],
          [ 93,  94,  95],
          [ 96,  97,  98]],

         [[ 99, 100, 101],
          [102, 103, 104],
          [105, 106, 107]],

         [[108, 109, 110],
          [111, 112, 113],
          [114, 115, 116]],

         [[117, 118, 119],
          [120, 121, 122],
          [123, 124, 125]],

         [[126, 127, 128],
          [129, 130, 131],
          [132, 133, 134]]],


        [[[135, 136, 137],
          [138, 139, 140],
          [141, 142, 143]],

         [[144, 145, 146],
          [147, 148, 149],
          [150, 151, 152]],

         [[153, 154, 155],
          [156, 157, 158],
          [159, 160, 161]],

         [[162, 163, 164],
          [165, 166, 167],
          [168, 169, 170]],

         [[171, 172, 173],
          [174, 175, 176],
          [177, 178, 179]]],


        [[[180, 181, 182],
          [183, 184, 185],
          [186, 187, 188]],

         [[189, 190, 191],
          [192, 193, 194],
          [195, 196, 197]],

         [[198, 199, 200],
          [201, 202, 203],
          [204, 205, 206]],

         [[207, 208, 209],
          [210, 211, 212],
          [213, 214, 215]],

         [[216, 217, 218],
          [219, 220, 221],
          [222, 223, 224]]]])
out:
tensor([[[[   0,    1,    2],
          [   3,    4,    5],
          [   6,    7,    8]],

         [[   9,   10,   11],
          [  12,   13,   14],
          [  15,   16,   17]],

         [[  18,   19,   20],
          [  21,   22,   23],
          [  24,   25,   26]],

         [[  27,   28,   29],
          [  30,   31,   32],
          [  33,   34,   35]],

         [[  36,   37,   38],
          [  39,   40,   41],
          [  42,   43,   44]]],


        [[[  90,   92,   94],
          [  96,   98,  100],
          [ 102,  104,  106]],

         [[ 108,  110,  112],
          [ 114,  116,  118],
          [ 120,  122,  124]],

         [[ 126,  128,  130],
          [ 132,  134,  136],
          [ 138,  140,  142]],

         [[ 144,  146,  148],
          [ 150,  152,  154],
          [ 156,  158,  160]],

         [[ 162,  164,  166],
          [ 168,  170,  172],
          [ 174,  176,  178]]],


        [[[ 270,  273,  276],
          [ 279,  282,  285],
          [ 288,  291,  294]],

         [[ 297,  300,  303],
          [ 306,  309,  312],
          [ 315,  318,  321]],

         [[ 324,  327,  330],
          [ 333,  336,  339],
          [ 342,  345,  348]],

         [[ 351,  354,  357],
          [ 360,  363,  366],
          [ 369,  372,  375]],

         [[ 378,  381,  384],
          [ 387,  390,  393],
          [ 396,  399,  402]]],


        [[[ 540,  544,  548],
          [ 552,  556,  560],
          [ 564,  568,  572]],

         [[ 576,  580,  584],
          [ 588,  592,  596],
          [ 600,  604,  608]],

         [[ 612,  616,  620],
          [ 624,  628,  632],
          [ 636,  640,  644]],

         [[ 648,  652,  656],
          [ 660,  664,  668],
          [ 672,  676,  680]],

         [[ 684,  688,  692],
          [ 696,  700,  704],
          [ 708,  712,  716]]],


        [[[ 900,  905,  910],
          [ 915,  920,  925],
          [ 930,  935,  940]],

         [[ 945,  950,  955],
          [ 960,  965,  970],
          [ 975,  980,  985]],

         [[ 990,  995, 1000],
          [1005, 1010, 1015],
          [1020, 1025, 1030]],

         [[1035, 1040, 1045],
          [1050, 1055, 1060],
          [1065, 1070, 1075]],

         [[1080, 1085, 1090],
          [1095, 1100, 1105],
          [1110, 1115, 1120]]]])
#oi,hw->oihw
weight = torch.arange(25).view(5, 5, 1, 1)
weight0 = weight.squeeze(3)
weight1 = weight0.squeeze(2)
b = torch.tensor([[1,2,3],[1,2,2],[1,1,1]])
out = torch.einsum('oi,hw->oihw', weight1, b)
print(out)

weight：
tensor([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24]])
b:
tensor([[1, 2, 3],
        [1, 2, 2],
        [1, 1, 1]])
out:
tensor([[[[ 0,  0,  0],
          [ 0,  0,  0],
          [ 0,  0,  0]],

         [[ 1,  2,  3],
          [ 1,  2,  2],
          [ 1,  1,  1]],

         [[ 2,  4,  6],
          [ 2,  4,  4],
          [ 2,  2,  2]],

         [[ 3,  6,  9],
          [ 3,  6,  6],
          [ 3,  3,  3]],

         [[ 4,  8, 12],
          [ 4,  8,  8],
          [ 4,  4,  4]]],


        [[[ 5, 10, 15],
          [ 5, 10, 10],
          [ 5,  5,  5]],

         [[ 6, 12, 18],
          [ 6, 12, 12],
          [ 6,  6,  6]],

         [[ 7, 14, 21],
          [ 7, 14, 14],
          [ 7,  7,  7]],

         [[ 8, 16, 24],
          [ 8, 16, 16],
          [ 8,  8,  8]],

         [[ 9, 18, 27],
          [ 9, 18, 18],
          [ 9,  9,  9]]],


        [[[10, 20, 30],
          [10, 20, 20],
          [10, 10, 10]],

         [[11, 22, 33],
          [11, 22, 22],
          [11, 11, 11]],

         [[12, 24, 36],
          [12, 24, 24],
          [12, 12, 12]],

         [[13, 26, 39],
          [13, 26, 26],
          [13, 13, 13]],

         [[14, 28, 42],
          [14, 28, 28],
          [14, 14, 14]]],


        [[[15, 30, 45],
          [15, 30, 30],
          [15, 15, 15]],

         [[16, 32, 48],
          [16, 32, 32],
          [16, 16, 16]],

         [[17, 34, 51],
          [17, 34, 34],
          [17, 17, 17]],

         [[18, 36, 54],
          [18, 36, 36],
          [18, 18, 18]],

         [[19, 38, 57],
          [19, 38, 38],
          [19, 19, 19]]],


        [[[20, 40, 60],
          [20, 40, 40],
          [20, 20, 20]],

         [[21, 42, 63],
          [21, 42, 42],
          [21, 21, 21]],

         [[22, 44, 66],
          [22, 44, 44],
          [22, 22, 22]],

         [[23, 46, 69],
          [23, 46, 46],
          [23, 23, 23]],

         [[24, 48, 72],
          [24, 48, 48],
          [24, 24, 24]]]])
#oi,ohw->oihw
weight = torch.arange(25).view(5, 5, 1, 1)
weight0 = weight.squeeze(3)
weight1 = weight0.squeeze(2)
#b = torch.tensor([[1,2,3],[1,2,2],[1,1,1],[1,1,1],[1,1,1]])
c = torch.ones(5,3,3)
c[0,:,:] = torch.tensor([1,2,3])
out = torch.einsum('oi,ohw->oihw', weight1, c)

print(out)

weight1：
tensor([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24]])

c:
tensor([[[1., 2., 3.],
         [1., 2., 3.],
         [1., 2., 3.]],

        [[1., 1., 1.],
         [1., 1., 1.],
         [1., 1., 1.]],

        [[1., 1., 1.],
         [1., 1., 1.],
         [1., 1., 1.]],

        [[1., 1., 1.],
         [1., 1., 1.],
         [1., 1., 1.]],

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

         [[ 1.,  2.,  3.],
          [ 1.,  2.,  3.],
          [ 1.,  2.,  3.]],

         [[ 2.,  4.,  6.],
          [ 2.,  4.,  6.],
          [ 2.,  4.,  6.]],

         [[ 3.,  6.,  9.],
          [ 3.,  6.,  9.],
          [ 3.,  6.,  9.]],

         [[ 4.,  8., 12.],
          [ 4.,  8., 12.],
          [ 4.,  8., 12.]]],


        [[[ 5.,  5.,  5.],
          [ 5.,  5.,  5.],
          [ 5.,  5.,  5.]],

         [[ 6.,  6.,  6.],
          [ 6.,  6.,  6.],
          [ 6.,  6.,  6.]],

         [[ 7.,  7.,  7.],
          [ 7.,  7.,  7.],
          [ 7.,  7.,  7.]],

         [[ 8.,  8.,  8.],
          [ 8.,  8.,  8.],
          [ 8.,  8.,  8.]],

         [[ 9.,  9.,  9.],
          [ 9.,  9.,  9.],
          [ 9.,  9.,  9.]]],


        [[[10., 10., 10.],
          [10., 10., 10.],
          [10., 10., 10.]],

         [[11., 11., 11.],
          [11., 11., 11.],
          [11., 11., 11.]],

         [[12., 12., 12.],
          [12., 12., 12.],
          [12., 12., 12.]],

         [[13., 13., 13.],
          [13., 13., 13.],
          [13., 13., 13.]],

         [[14., 14., 14.],
          [14., 14., 14.],
          [14., 14., 14.]]],


        [[[15., 15., 15.],
          [15., 15., 15.],
          [15., 15., 15.]],

         [[16., 16., 16.],
          [16., 16., 16.],
          [16., 16., 16.]],

         [[17., 17., 17.],
          [17., 17., 17.],
          [17., 17., 17.]],

         [[18., 18., 18.],
          [18., 18., 18.],
          [18., 18., 18.]],

         [[19., 19., 19.],
          [19., 19., 19.],
          [19., 19., 19.]]],


        [[[20., 20., 20.],
          [20., 20., 20.],
          [20., 20., 20.]],

         [[21., 21., 21.],
          [21., 21., 21.],
          [21., 21., 21.]],

         [[22., 22., 22.],
          [22., 22., 22.],
          [22., 22., 22.]],

         [[23., 23., 23.],
          [23., 23., 23.],
          [23., 23., 23.]],

         [[24., 24., 24.],
          [24., 24., 24.],
          [24., 24., 24.]]]])

mytzs123
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
torch.einsum.docx
09-16
`torch.einsum`是PyTorch库中的一个高级函数，用于执行基于Einstein summation convention（也称为Einstein notation）的多维数组操作。它能够简洁地表示各种线性代数运算，如矩阵转置、求和、矩阵乘法、点积、外积...
torch.einsum用法详解
bj_zhb的博客
03-20 6077
是PyTorch中的一个函数，用于执行爱因斯坦求和约定（Einstein summation）运算。它提供了一种灵活而强大的方式来执行多维张量的操作和变换。其中，equation是一个字符串，用于指定爱因斯坦求和约定的运算方式，operands是一个或多个输入张量。在equation中，你可以使用大写字母表示张量的维度标识符，使用小写字母表示对应维度的长度。通过指定输入张量和输出张量之间的维度关系，你可以定义所需的运算操作。下面是一个简单的例子，展示了如何使用# 两个向量的点积。
Pytorch中, torch.einsum详解。
热门推荐
a2806005024的专栏
07-19 7万+
爱因斯坦简记法：是一种由爱因斯坦提出的，对向量、矩阵、张量的求和运算的求和简记法。 在该简记法当中，省略掉的部分是：1）求和符号与2）求和号的下标 省略规则为：默认成对出现的下标（如下例1中的i和例2中的k）为求和下标。 我们举例说明： 1）用简化表示内积 其中o为输出。 2) 用简化表示矩阵乘法 其中为输出矩阵的第ij个元素。 这样的求和简记法，能够以一种统一的方...
torch.einsum 解析
qq_18063797的博客
07-02 167
运算表达式 “b k d l, k c d -> b k c l” 中，k 在输入表达式 b k d l 和 k c d 中都出现，且出现在输出表达式 b k c l 中，该维度仅进行点乘，无求和运算。b 仅在第一个输入表达式出现，l 仅在第一个输入表达式出现，c 仅在第二个输入表达式出现，因此 blc 均会出现在最终表达式，因为没有向量求和消掉维度。第一个矩阵形状为(b,k,d,l)，第二个矩阵形状为(k,c,d)，输出形状为(b,k,c,l)。这也是torch.einsum最常规的用法。
torch.einsum() 用法说明
欢迎关注，共同进步！
12-25 5231
这里，j 是求和下标，i 和 k 是输出下标（有关原因的更多详细信息，请参见下面的部分）。例外情况是，如果对相同的输入操作数重复下标，在这种情况下，此操作数的标有此下标的维度必须在大小上匹配，并且操作数将被其沿这些维度的对角线替换。，它将覆盖下标未覆盖的维度，例如，对于具有 5 维的输入操作数，等式“ab…中的字母） ，用逗号 (‘,’) 分隔每个操作数的下标，例如’ij,jk’指定两个二维操作数的下标。中相同数量的维度，但省略号的“形状”（它们覆盖的维度的大小）必须一起传播。) – 爱因斯坦求和的下标。
「解析」如何优雅的学习 torch.einsum()
绿色羽毛
01-29 1万+
einsum方法解析：einsum(爱因斯坦求和) 是Pytorch、TensorFlow、numpy中一个十分优雅的方法。Einsum 可以计算向量、矩阵、张量运算，包括计算 transposes、sum、column/row sum、Matrix-Vector Multiplication、Matrix-Matrix Multiplication。如果利用得当，sinsum绝对是你科研路上的一把利器，可完全代替其他的矩阵计算方法。
5min看懂torch.einsum()计算方法-torch.einsum()手动推导详解
罟霖同学的站点
09-03 1304
 本文将从实际复杂案例的角度对torch.einsum()的计算过程进行分析，一步一步的推导最终输出的每个元素和输入元素之间的关系。
pytorch中einsum详解
欢迎来到道的世界
12-20 4510
引言  在线性代数里，经常会遇到各种计算操作符号，比如矩阵的点积，外积，HHH积，KKK积，转置等。爱因斯坦求和约定提供了一套简单优雅的规则可以实现以上操作，目的是省略掉求和公式中的求和号“+”。 定义（爱因斯坦求和约定）：如果两个相同的指标出现在指标符号公式的同一项中，则表示对该指标遍历整个取值范围求和。 爱因斯坦求和约定具体的规则可以归结为如下几条 在同一项中，如果同一指标成对出现，就表示遍历其取值范围求和 公式中成对出现的指标叫做哑指标亦或哑标，表示哑标的小写字母可以用另一个小写字母替换，并且
PyTorch里面的torch.nn.Parameter()详解
09-18
在PyTorch中，`torch.nn.Parameter()`是一个非常关键的类，它用于创建可学习的参数。这些参数通常是神经网络模型中的权重和偏置，它们在训练过程中会被优化算法更新以最小化损失函数。本文将深入探讨`torch.nn....
Pythorch中torch.nn.LSTM()参数详解
04-27
Pythorch中torch.nn.LSTM()参数详解；Pythorch中torch.nn.LSTM()参数详解；Pythorch中torch.nn.LSTM()参数详解；Pythorch中torch.nn.LSTM()参数详解；Pythorch中torch.nn.LSTM()参数详解；Pythorch中torch.nn.LSTM()...
torch.cat()函数的官方解释，详解以及例子
01-20
一般torch.cat()是为了把函数torch.stack()得到tensor进行拼接而存在的。 区别参考链接torch.stack()，但是本文主要说cat()。 前言 和python中的内置函数cat()， 在使用和目的上，是没有区别的。 1. cat()官方解释 ...
【Pytorch】科研代码技巧—Einsum爱因斯坦求和约定
炼丹笔记
09-22 1778
不知大家在看论文代码的时候是否会常常看见 torch.einsum()，这玩意儿看起来是真的抽象，但是深入了解后发现它原来这么好用。
【Python】torch.einsum()解析
Danger的博客
03-05 2829
【Python】torch.einsum()解析
Python的torch.einsum计算方法
昊大侠的博客
11-14 5226
涉及以下内容 简述 爱因斯坦求和约定（einsum）具有简洁优雅的规则，实现包括但不限于：向量内积，向量外积，矩阵乘法，转置和张量收缩等张量操作 例如 a = torch.rand(3, 4)，b = torch.rand(4, 5)，c = torch.einsum("ik,kj->ij", [a, b]) # einsum 的第一个参数 "ik,kj->ij" 描述张量的计算规则，且维度的字符只能是26个英文字母 'a' - 'z' # einsum 的第一个参数可以不写包括箭头在内的右
torch.einsum()
最新发布
weixin_44012667的博客
07-13 394
是 PyTorch 中一个功能强大的函数，用于执行爱因斯坦求和约定（Einstein summation convention）。这个函数可以用来进行多维数组（张量）间的各种操作，如矩阵乘法、内积、外积、转置和更多复杂的张量操作。
掌握numpy.einsum与torch.einsum：提升科学计算与深度学习中的运算效率和代码可读性
m0_51661400的博客
12-26 1964
本文介绍了numpy.einsum和torch.einsum在科学计算和深度学习中的应用，包括Einstein求和记号的概念及其简化复杂运算的作用。详细阐述了两者的使用方法，如numpy.einsum的基础操作和torch.einsum在复杂运算如注意力机制以及自动微分中的优势。通过对比einsum与手动实现的嵌套循环运算，深入理解其机制。该博客旨在帮助读者熟练掌握这两种工具，提升计算效率和代码可读性，以应对各类科学计算和深度学习任务。
【Pytorch】一文向您详细介绍 torch.einsum() 的用法
创作高质量博文，分享知识，共同进步！
05-30 1712
🚀 解锁PyTorch强大功能，一文掌握`torch.einsum()`用法！🌟 🔍 深度解析`torch.einsum()`基础与进阶，助你轻松驾驭多维张量运算。 🌈 高级技巧让你举一反三，灵活应对各种复杂计算。 💡 实用建议，助你以小见大，优化模型性能。 🚀 总结与展望，带你领略`torch.einsum()`的无限可能！#PyTorch #torch.einsum #深度学习 #张量运算#
torch.einsum用法
sinat_34461199的博客
01-07 745
是 PyTorch 中的一个强大工具，它允许你通过 Einstein summation convention（爱因斯坦求和约定）来执行复杂的张量操作。使用这种约定，你可以用一个字符串来指定张量操作的维度规则。这个函数非常灵活，可以用于实现各种张量运算，如元素相乘、矩阵乘法、批量矩阵乘法、迹等。其中，equation是一个字符串，指定了张量操作的约定；*operands是要操作的张量。以下是。
torch.einsum
07-13
torch.einsum是PyTorch中的一个函数，用于执行Einstein求和约定操作。它可以用来执行各种线性代数运算，如矩阵乘法、矩阵转置、矩阵对角线提取等。 使用torch.einsum函数，你可以通过指定一个字符串表达式来描述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值