深度学习：张量 介绍

张量[1]是向量和矩阵到 n 维的推广。了解它们如何相互作用是机器学习的基础。

简介

虽然张量看起来是复杂的对象，但它们可以理解为向量和矩阵的集合。理解向量和矩阵对于理解张量至关重要。

向量是元素的一维列表：

alt

矩阵是向量的二维列表：

alt

下标表示（行，列）。考虑矩阵的另一种方式是用向量作为元素的向量。请注意，它们通常用大写字母表示。

3D 张量可以被视为三维矩阵列表：

alt

考虑 3D 张量的另一种方式是使用矩阵作为元素的向量。请注意，在本文中它们是用书法大写字母标注的。

4D 张量可以被认为是 3D 张量的四维列表：

alt

考虑 4D 张量的另一种方式是使用 3D 张量作为其元素的向量。这些可能会变得越来越复杂，但这是继续使用张量进行运算所必需的程度。

向量运算

alt

假设这些是相同长度的向量，i。接下来的操作主要是按元素进行的。这意味着每个向量中的相应元素被一起操作。

加法

alt 
import torch

x = torch.tensor([1, 3, 5])
y = torch.tensor([3, 7, 4])

x + y

# tensor([ 4, 10,  9])

减法

alt 
x = torch.tensor([1, 3, 5])
y = torch.tensor([3, 7, 4])

x - y

# tensor([-2, -4,  1])

点乘

alt

这也可以用求和来表示：

alt 
x = torch.tensor([1, 3, 5])
y = torch.tensor([3, 7, 4])

torch.dot(x, y) # 1*3 + 3*7 + 5*4 = 3 + 21 + 20 = 44

# tensor(44)

这也可以用 x @ y 来执行。点积的输出是一个标量。它不返回向量。

Hadamard（乘法）

alt

Hadamard 乘积用于执行逐元素乘法并返回一个向量。

x = torch.tensor([1, 3, 5])
y = torch.tensor([3, 7, 4])

x * y

# tensor([ 3, 21, 20])

标量乘法

alt

k 是标量，在大多数情况下是实数。

k = 5
x = torch.tensor([1, 3, 5])

k * x

# tensor([ 5, 15, 25])

由于 k 可以是分数，因此这也可以被视为标量除法。

矩阵乘法

请记住，矩阵是向量的集合。相同的操作适用于向量，但在涉及行和列时还有一些规则需要注意。

假设如下，其中 X 和 Y 的形状为 (4,3)：

alt

加法

alt 
X = torch.tensor([[1, 3, 5],
                  [3, 6, 1],
                  [6, 8, 5],
                  [7, 3, 2]])

Y = torch.tensor([[6, 3, 2],
                  [8, 5, 4],
                  [3, 1, 7],
                  [1, 8, 3]])

X + Y

# tensor([[ 7,  6,  7],
        [11, 11,  5],
        [ 9,  9, 12],
        [ 8, 11,  5]])

减法

alt 
X = torch.tensor([[1, 3, 5],
                  [3, 6, 1],
                  [6, 8, 5],
                  [7, 3, 2]])

Y = torch.tensor([[6, 3, 2],
                  [8, 5, 4],
                  [3, 1, 7],
                  [1, 8, 3]])

X - Y

# tensor([[-5,  0,  3],
        [-5,  1, -3],
        [ 3,  7, -2],
        [ 6, -5, -1]])

点积

alt

在执行矩阵乘法时，重要的是要将矩阵视为由向量组成。通过这个视图，就可以清楚如何在矩阵上执行点积。发生乘法的唯一方法是第一个矩阵中的行数与第二个矩阵中的列数匹配。这导致：

  • (m, n) x (n, r) = (m, r)

如果情况并非如此，则必须转置其中一个矩阵以适应该顺序；这会切换行和列，但保留点积的向量。

在上图中，很明显，左侧矩阵中的每个向量（或行）都乘以第二个矩阵中的每个向量（或列）。因此，在此示例中，A 中的每个向量必须与 B 中的每个向量相乘，从而产生 16 个点积。

X = torch.tensor([[1, 3, 5],
                  [3, 6, 1],
                  [6, 8, 5],
                  [7, 3, 2]])

Y = torch.tensor([[6, 3, 2],
                  [8, 5, 4],
                  [3, 1, 7],
                  [1, 8, 3]])

X.matmul(Y.T) # X @ Y.T

# tensor([[ 25,  43,  41,  40],
        [ 38,  58,  22,  54],
        [ 70, 108,  61,  85],
        [ 55,  79,  38,  37]])

Hadamard 积

alt

Hadamard 乘积是逐元素乘法，因此其执行方式与加法和减法相同。

X = torch.tensor([[1, 3, 5],
                  [3, 6, 1],
                  [6, 8, 5],
                  [7, 3, 2]])

Y = torch.tensor([[6, 3, 2],
                  [8, 5, 4],
                  [3, 1, 7],
                  [1, 8, 3]])

X * Y

# tensor([[ 6,  9, 10],
        [24, 30,  4],
        [18,  8, 35],
        [ 7, 24,  6]])

标量乘法

alt 
k = 5
X = torch.tensor([[1, 3, 5],
                  [3, 6, 1],
                  [6, 8, 5],
                  [7, 3, 2]])

k * X

# tensor([[ 5, 15, 25],
        [15, 30,  5],
        [30, 40, 25],
        [35, 15, 10]])

三维张量运算

张量运算要求两个张量具有相同的大小，除非正在执行点积。

对于本节中的逐元素运算，假设两个张量的形状为 (3, 3, 2)。这意味着两个张量都包含三个 (3,2) 矩阵。如下所示：

import torch

gen = torch.Generator().manual_seed(2147483647)

X = torch.randint(0, 10, (3, 3, 2), generator=gen)
Y = torch.randint(0, 10, (3, 3, 2), generator=gen)

X = tensor([[[1, 4],
             [9, 2],
             [3, 0]],

            [[4, 6],
             [7, 7],
             [1, 5]],

            [[6, 8],
             [1, 4],
             [4, 9]]])

Y = tensor([[[8, 0],
             [3, 6],
             [6, 0]],

            [[9, 1],
             [0, 0],
             [2, 2]],

            [[7, 1],
             [8, 1],
             [9, 0]]])

加法

加法是按元素进行的，并且按预期执行。每个张量中对应的元素相互相加。

X + Y

tensor([[[ 9,  4],
         [12,  8],
         [ 9,  0]],

        [[13,  7],
         [ 7,  7],
         [ 3,  7]],

        [[13,  9],
         [ 9,  5],
         [13,  9]]])

减法

减法也是按元素进行的并且按预期执行。

X - Y

tensor([[[-7,  4],
         [ 6, -4],
         [-3,  0]],

        [[-5,  5],
         [ 7,  7],
         [-1,  3]],

        [[-1,  7],
         [-7,  3],
         [-5,  9]]])

点积

alt

张量乘法比二维中的张量乘法稍微复杂一些。之前，矩阵乘法只有满足以下条件才能发生：

  • (m, n) x (n, r) = (m, r)

在三个维度上，这仍然是一个要求。但是，第一个轴必须相同：

  • (z, m, n) x (z, n, r) = (z, m, r)

为什么是这样？嗯，如前所述，二维的点积主要是将向量彼此相乘。在三维中，重点是按矩阵相乘，然后对这些矩阵中的每个向量执行点积。

上图应该有助于解释这一点。将两个 3D 张量视为矩阵向量可能会有所帮助。由于点积是通过按元素相乘然后求和来执行的，因此首先发生的事情是每个矩阵与其相应的矩阵相乘。当这种情况发生时，矩阵乘法会导致矩阵中的每个向量与其他向量执行点积。从某种意义上说，它就像一个嵌套的点积。

为了使 和 彼此相乘，必须调换 的第二轴和第三轴。并且两者的大小均为 (3, 3, 2)。这意味着必须变成(3,2,3)。这可以使用 Y.permute(0, 2, 1) 来完成，它转置第二和第三轴。或者，可以使用 Y.transpose(1,2)。

print(Y.transpose(1,2))
print(Y.transpose(1,2).shape) # Y.permute(0, 2, 1)

tensor([[[8, 3, 6],
         [0, 6, 0]],

        [[9, 0, 2],
         [1, 0, 2]],

        [[7, 8, 9],
         [1, 1, 0]]])

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

通过适当的调整大小，现在可以使用 matmul 或 @ 执行张量乘法。输出的形状应为 (3, 3, 2) x (3, 2, 3) = (3, 3, 3)。

X.matmul(Y.transpose(1,2)) # X @ Y.transpose(1,2)

tensor([[[ 8, 27,  6],
         [72, 39, 54],
         [24,  9, 18]],

        [[42,  0, 20],
         [70,  0, 28],
         [14,  0, 12]],

        [[50, 56, 54],
         [11, 12,  9],
         [37, 41, 36]]])

Hadamard 积

Hadamard 积的性能符合预期，并在 3D 张量的矩阵中按元素相乘。

X * Y

tensor([[[ 8,  0],
         [27, 12],
         [18,  0]],

        [[36,  6],
         [ 0,  0],
         [ 2, 10]],

        [[42,  8],
         [ 8,  4],
         [36,  0]]])

标量乘法

标量乘法也按预期执行。

k = 5
k*X

tensor([[[ 5, 20],
         [45, 10],
         [15,  0]],

        [[20, 30],
         [35, 35],
         [ 5, 25]],

        [[30, 40],
         [ 5, 20],
         [20, 45]]])

四维张量运算

四维张量运算仍然要求两个张量具有相同的大小。

对于本部分，假设形状为 (2, 3, 3, 2)。这意味着两个 4D 张量都包含两个 3D 张量，并且每个张量都包含三个 (3,2) 矩阵。如下所示：

import torch

gen = torch.Generator().manual_seed(2147483647)

X = torch.randint(0, 10, (2, 3, 3, 2), generator=gen)
Y = torch.randint(0, 10, (2, 3, 3, 2), generator=gen)

X
# 4d tensor
tensor([
# 3d tensor
        [
         # matrix 1
         [[1, 4],
          [9, 2],
          [3, 0]],
         # matrix 2
         [[4, 6],
          [7, 7],
          [1, 5]],
         # matrix 3
         [[6, 8],
          [1, 4],
          [4, 9]]],

# 3d tensor
        [
         # matrix 1
         [[8, 0],
          [3, 6],
          [6, 0]],
         # matrix 2
         [[9, 1],
          [0, 0],
          [2, 2]],
         # matrix 3
         [[7, 1],
          [8, 1],
          [9, 0]]]])

Y
# 4d tensor
tensor([
# 3d tensor
        [
         # matrix 1 
         [[6, 3],
          [6, 4],
          [5, 7]],
         # matrix 2
         [[3, 7],
          [2, 0],
          [5, 1]],
         # matrix 3
         [[0, 4],
          [0, 8],
          [0, 6]]],

# 3d tensor
        [
         # matrix 1
         [[0, 5],
          [8, 6],
          [1, 0]],
         # matrix 2
         [[5, 1],
          [1, 6],
          [1, 2]],
         # matrix 3
         [[6, 0],
          [2, 6],
          [1, 5]]]])

加法

加法、减法和哈达玛积仍然按预期按元素执行。

X + Y

tensor([[[[ 7,  7],
          [15,  6],
          [ 8,  7]],

         [[ 7, 13],
          [ 9,  7],
          [ 6,  6]],

         [[ 6, 12],
          [ 1, 12],
          [ 4, 15]]],


        [[[ 8,  5],
          [11, 12],
          [ 7,  0]],

         [[14,  2],
          [ 1,  6],
          [ 3,  4]],

         [[13,  1],
          [10,  7],
          [10,  5]]]])

减法

X - Y

tensor([[[[-5,  1],
          [ 3, -2],
          [-2, -7]],

         [[ 1, -1],
          [ 5,  7],
          [-4,  4]],

         [[ 6,  4],
          [ 1, -4],
          [ 4,  3]]],


        [[[ 8, -5],
          [-5,  0],
          [ 5,  0]],

         [[ 4,  0],
          [-1, -6],
          [ 1,  0]],

         [[ 1,  1],
          [ 6, -5],
          [ 8, -5]]]])

点积

alt

在四维中，张量乘法将具有与三维和二维中相同的要求。它还需要第一轴和第二轴与两个张量匹配：

  • (c、z、m、n) x (c、z、n、r) = (c、z、m、r)

在三维空间中，进行矩阵乘法，然后进行向量之间的点积。相同的步骤将在四个维度中发生，但首先将每个 3D 张量与其相应的 3D 张量相乘。然后，它们的每个矩阵将相互相乘。最后，它们的向量将相互执行点积。这可以在上图中看到。

对于本例， 和 的大小为 (2, 3, 3, 2)。为了进行乘法运算，必须调换 的第三轴和第四轴。这可以按照与之前使用 Y.permute(0, 1, 3, 2) 或 Y.transpose(2,3) 相同的方式完成。转置后的形状为 (2, 3, 2, 3)。

结果的形状应为 (2, 3, 3, 2) x (2, 3, 2, 3) = (2,3,3,3)。这意味着将有两个 3D 张量，每个张量将包含三个 (3,3) 矩阵。这个结果可以使用 matmul 或 @ 获得。

X.matmul(Y.transpose(2,3)) # X @ Y.transpose(2,3)

tensor([[[[18, 22, 33],
          [60, 62, 59],
          [18, 18, 15]],

         [[54,  8, 26],
          [70, 14, 42],
          [38,  2, 10]],

         [[32, 64, 48],
          [16, 32, 24],
          [36, 72, 54]]],


        [[[ 0, 64,  8],
          [30, 60,  3],
          [ 0, 48,  6]],

         [[46, 15, 11],
          [ 0,  0,  0],
          [12, 14,  6]],

         [[42, 20, 12],
          [48, 22, 13],
          [54, 18,  9]]]])

Hadamard 积

X * Y

tensor([[[[ 6, 12],
          [54,  8],
          [15,  0]],

         [[12, 42],
          [14,  0],
          [ 5,  5]],

         [[ 0, 32],
          [ 0, 32],
          [ 0, 54]]],


        [[[ 0,  0],
          [24, 36],
          [ 6,  0]],

         [[45,  1],
          [ 0,  0],
          [ 2,  4]],

         [[42,  0],
          [16,  6],
          [ 9,  0]]]])

标量乘法

k = 5
k * X

tensor([[[[ 5, 20],
          [45, 10],
          [15,  0]],

         [[20, 30],
          [35, 35],
          [ 5, 25]],

         [[30, 40],
          [ 5, 20],
          [20, 45]]],


        [[[40,  0],
          [15, 30],
          [30,  0]],

         [[45,  5],
          [ 0,  0],
          [10, 10]],

         [[35,  5],
          [40,  5],
          [45,  0]]]])

Reference

[1]

Source: https://medium.com/@hunter-j-phillips/a-simple-introduction-to-tensors-c4a8321efffc

本文由 mdnice 多平台发布

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/123086.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Ajax学习笔记第三天

Ajax学习笔记第三天

做决定之前仔细考虑，一旦作了决定就要勇往直前、坚持到底！ 【1 ikunGG邮箱注册】 整个流程展示： 1.文件目录 2.页面效果展示及代码 mysql数据库中的初始表 2.1 主页 09.html:里面代码部分解释 display: inline-block; 让块元素h1变成行内…
阅读更多...
OpenCV C++ 图像处理实战 ——《缺陷检测》

OpenCV C++ 图像处理实战 ——《缺陷检测》

OpenCV C++ 图像处理实战 ——《缺陷检测》 一、结果演示二、缺陷检测算法2.1、多元模板图像2.2、训练差异模型三、图像配准3.1 功能源码3.1 功能效果四、多元模板图像4.1 功能源码五、缺陷检测5.1 功能源码六、源码测试图像下载总结一、结果演示
阅读更多...
pytorch笔记：TRIPLETMARGINLOSS

pytorch笔记：TRIPLETMARGINLOSS

1 介绍 创建一个衡量三元组损失的标准，给定输入张量 x1​、x2​ 和 x3​ 以及一个大于0的间距值。这用于测量样本之间的相对相似性。一个三元组由a、p和n组成（锚点、正例和负例）。所有输入张量的形状都应为 (N,D) 2 基本使用方法 torch.nn.…
阅读更多...
AD9371 官方例程HDL详解之JESD204B RX侧格式配置

AD9371 官方例程HDL详解之JESD204B RX侧格式配置

AD9371 系列快速入口 AD9371ZCU102 移植到 ZCU106 ： AD9371 官方例程构建及单音信号收发 采样率和各个时钟之间的关系 ： AD9371 官方例程HDL详解之JESD204B TX侧时钟生成 （三） 参考资料： UltraScale Architecture G…
阅读更多...
【AD9361 数字接口CMOS LVDSSPI】D 串行数据之SPI

【AD9361 数字接口CMOS LVDSSPI】D 串行数据之SPI

【AD9361 数字接口CMOS &LVDS&SPI】D部分 接续 【AD9361 数字接口CMOS &LVDS&SPI】A 并行数据之CMOS 串行外设接口（SPI） SPI总线为AD9361的所有数字控制提供机制。每个SPI寄存器的宽度为8位，每个寄存器包含控制位、状态监视…
阅读更多...
【OpenCV实现平滑图像金字塔，轮廓：入门】

【OpenCV实现平滑图像金字塔，轮廓：入门】

文章目录 概要图像金字塔轮廓：入门 概要 文章内容的概要： 平滑图像金字塔： 图像金字塔是什么？ 图像金字塔是指将原始图像按照不同的分辨率进行多次缩小（下采样）得到的一系列图像。这种处理方式常用于图像…
阅读更多...
数据链路层和DNS之间的那些事~

数据链路层和DNS之间的那些事~

数据链路层，考虑的是两个节点之间的传输。这里面的典型协议也很多，最知名的就是“以太网”。我们本篇主要介绍的就是以太网协议。这个协议规定了数据链路层，也规定了物理层的内容。 目录 以太网帧格式 帧头 载荷 帧尾 DNS 从输入URL到…
阅读更多...
[读论文] On Joint Learning for Solving Placement and Routing in Chip Design

[读论文] On Joint Learning for Solving Placement and Routing in Chip Design

0. Abstract 由于 GPU 在加速计算方面的优势和对人类专家的依赖较少，机器学习已成为解决布局和布线问题的新兴工具，这是现代芯片设计流程中的两个关键步骤。它仍处于早期阶段，存在一些基本问题：可扩展性、奖励设计和端到端学习范…
阅读更多...
获取IEEE会议论文的标题和摘要

获取IEEE会议论文的标题和摘要

获取IEEE会议论文的标题和摘要 – 潘登同学的爬虫笔记 文章目录 获取IEEE会议论文的标题和摘要 -- 潘登同学的爬虫笔记 打开IEEE的高级搜索环境准备完整爬虫过程获取文章地址翻译函数获取文章标题和摘要 前几天接到导师的一个任务，要我去找找IEEE Transactions on K…
阅读更多...
vue源码分析（七）—— createComponent

vue源码分析（七）—— createComponent

文章目录 前言一、createComponent 参数说明二、createComponent 源码详解1.baseCtor的实际指向2.extend 方法3.判断Ctor是否是函数的判断4.installComponentHooks方法5.返回一个带标识的组件 vnode 前言 createComponent文件的路径： src\core\vdom\create-componen…
阅读更多...
【Qt之控件QKeySequenceEdit】分析及使用

【Qt之控件QKeySequenceEdit】分析及使用

描述 QKeySequenceEdit小部件允许输入一个QKeySequence。 该小部件允许用户选择一个QKeySequence，通常用作快捷键。当小部件获取焦点时，录制将开始，并在用户释放最后一个键后的一秒钟结束。 用户可以使用输入键盘来输入键序列。通过调用get…
阅读更多...
Postman日常操作

Postman日常操作

一.Postman介绍 1.1第一个简单的demo 路特斯（英国汽车品牌）_百度百科 (baidu.com) 1.2 cookie 用postman测试需要登录权限的接口时，会被拦截，解决办法就是每次请求接口前，先执行登录，然后记住cookie或者to…
阅读更多...
python html(文件/url/html字符串)转pdf

python html(文件/url/html字符串)转pdf

安装库 pip install pdfkit第二步 下载程序wkhtmltopdf https://wkhtmltopdf.org/downloads.html 下载7z压缩包 解压即可, 无需安装 解压后结构应该是这样, 我喜欢放在项目里, 相对路径引用(也可以使用绝对路径, 放其他地方) import pdfkit# 将 wkhtmltopdf.exe程序 路径 p…
阅读更多...
LVS-keepalived实现高可用

LVS-keepalived实现高可用

概念： 本章核心： Keepalived为LVS应运而生的高可用服务。LVS的调度无法做高可用，预算keepalived这个软件，实现了调度器的高可用。 但是：Keeplived不是专门为LVS集群服务的，也可以做其他服务器的高可用 LVS…
阅读更多...
STM32F103的中断

STM32F103的中断

文章目录 STM32F103的NVICSTM32F103 的中断优先级分组 STM32F103的NVIC CM3 内核支持 256 个中断，其中包含了 16 个内核中断和 240 个外部中断，并且具有 256级的可编程中断设置。 CM3中每个中断通道都具备自己的8位中断优先级控制字节， 但ST…
阅读更多...
【ROS入门】雷达、摄像头及kinect信息仿真以及显示

【ROS入门】雷达、摄像头及kinect信息仿真以及显示

文章结构 雷达信息仿真以及显示Gazebo仿真雷达配置雷达传感器信息xacro文件集成启动仿真环境 Rviz显示雷达数据 摄像头信息仿真以及显示Gazebo仿真摄像头新建xacro文件，配置摄像头传感器信息xacro文件集成启动仿真环境 Rviz显示摄像头数据 kinect信息仿真以及显示Ga…
阅读更多...
不做学习的奴隶，更要注重生活

不做学习的奴隶，更要注重生活

下面是国外社交软件 i n s ins ins上近 40 40 40万点赞的帖子。 “睡8小时，而不是6小时。 锻炼1小时，而不是4小时。 学习3小时，而不是10小时。 读书2小时，而不是5小时。 深度工作3小时，而不是12小时。 你是人&#xff…
阅读更多...
arch linux 安装 vsftpd 配置虚拟用户

arch linux 安装 vsftpd 配置虚拟用户

后面操作会直接基于 yay 操作 自行查找如何安装 yay 公司经常会用到 ftp 服务 不想用 apache 的 ftp server 所以自己在小机器上撞了 arch linux 用来安装软件 跑程序等。 1. 安装 vsftpd yay vsftpd --noconfirm选择 1 安装 输入密码 2. 安装 pam_pwdfile 安装 pam_pwdf…
阅读更多...
【软件安装】Windows系统中使用miniserve搭建一个文件服务器

【软件安装】Windows系统中使用miniserve搭建一个文件服务器

这篇文章，主要介绍如何在Windows系统中使用miniserve搭建一个文件服务器。 目录 一、搭建文件服务器 1.1、下载miniserve 1.2、启动miniserve服务 1.3、指定根目录 1.4、开启访问日志 1.5、指定启动端口 1.6、设置用户认证 1.7、设置界面主题 （…
阅读更多...
华为终端智能家居应用方案

华为终端智能家居应用方案

PLC-IoT概述 华为智能PLC-IoT工业物联网系列通信模块是基于电力线宽带载波技术的产品，实现数据在电力线上双向、高速、稳定的传输，广泛适用于电力、交通、工业制造、智能家居等领域，PLC-IoT通信模块包含头端和尾端两种类型，头端配…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023