精华内容
下载资源
问答
  • 四、张量表示

    2020-07-26 17:55:22
    前面我们学习了张量的基本概念,我们知道,一个标量我们定义为零阶张量,一个矢量我们称为一阶张量,矩阵称为二阶张量。。。       为了更加便捷的表示张量,我们用一个新的方式表示...

    张量表示


    1. 张量的另一种表示方法


          前面我们学习了张量的基本概念,我们知道,一个标量我们定义为零阶张量,一个矢量我们称为一阶张量,矩阵称为二阶张量。。。

          为了更加便捷的表示张量,我们用一个新的方式表示张量:用一个有 NN 个腿的圆形形表示 NN 阶张量,如下所示:
    在这里插入图片描述
          上图的第一行我们用一个圆形直接表示一个标量,因为标量是零阶张量,所以我们不在旁边加边。上图的第二行我们为圆形加了一个边,我们称为一阶张量,同时我们可以在边上写一个数表示该维度的大小,因此第二行表示一个 ii 维的一阶张量(向量)。同理我们通过在这个圆上不断的增加边的个数来表示更高阶的张量,边上的数字可以用来表示每个维度有多少元素。

          每个张量结点我们可以用不同的图形来表示,上面我们都是用圆形表示的结点,同样我们也可以用方形,三角形等来表示一个结点,我们可以自己选择。


    2. 张量的缩并

          下图我们用蓝色的图形表示一个二阶张量 MijM_{ij} ,用绿色图形表示一个二阶张量 NjkN_{jk} ,二阶张量是一个矩阵,因此我们可以表示一个矩阵的乘积如下所示,上面两个矩阵的乘积得到的结果是一个 i×ki×k 的矩阵,我们将值相同的两个边合并,将合并后的整体视为一个张量,它表示一个 i×ki×k 的张量,我们将相乘的过程用求和公式表示为 (MN)ik=jMijNjk(MN)_{ik}=\sum_jM_{ij}N_{jk}
    在这里插入图片描述

          为了更加简洁的表示张量相乘,我们将两个相乘的结点合并,将他们看成一个结点,忽略他们之间相乘的细节,如下图所示,直接一个结点表示相乘的结果。将具有相同大小边的张量合并为一个的过程称为张量的缩并。

    在这里插入图片描述

          下面我们用几个例子来更加深入的了解一下张量的缩并。

          一个矩阵和向量的乘积为一个向量。矩阵和向量我们可以表示为二阶张量和一阶张量,我们可以用图表示他们的乘积如下,讲得到的结果视为一个整体,表示一个一阶张量,下面的结果我们可以记为 ci=Ajibj\pmb{c}_i=A_{ji}\pmb{b}_j 。从表达式我们可以看出,张量的缩并可以表示为相同角标的合并,因为两个张量都包含角标 jj 我们可以通过缩并消去 jj 得到一个新的张量。

    在这里插入图片描述

          两个或更多的张量通过缩并组合在一起就形成了张量网络,如下
    在这里插入图片描述

          上面我们说了,节点的形状并不是只能是圆形,我们可以选择任意的形状,如下所示,我们可以选择方形或半圆形。

    在这里插入图片描述

          当我们选择半圆形做为节点时,我们可以通过他的对称图形来表示这个矩阵的转置,如下所示。

          矩阵的迹我们可以表示为只有一条指向自己的边的结点,如下所示,因为他没有自由边,所以他表示一个数,这和矩阵的迹是吻合的。

    在这里插入图片描述

          前面我们说过,对于任意的矩阵,我们都可以通过奇异值分解,变为三个矩阵相乘,我们也可以用这种图示的方法表示如下。

    在这里插入图片描述

          我们同样可以用张量网络来表示 CP 分解,如下所示, CP 分解是将张量分解为几个秩一张量的和,每个秩一张量可以表示为几个向量的外积,我们用一个圆圈圈住表示里面若干个向量的外积,所以 CP 分解就可以表示如下

    在这里插入图片描述

    3. 张量缩并的 python 实现


    张量的缩并有两种实现方式,分别是通过 numpy 的 tensordot 函数和 einsum 函数,下面是两种方法的具体代码:

    import numpy as np
    
    A = np.random.randn(5, 3, 2)   #随机生成 5×3×2 的张量
    B = np.random.randn(3, 6, 4)
    C1 = np.tensordot(A, B, [[1], [0]])     #后面两个表示将 a 的第一个指标和 b 的第 0  个指标收缩
    print('The shape of C = ')
    print(C1.shape)
    
    
    A = np.random.randn(5, 3, 3)
    B = np.random.randn(6, 3, 3)
    C = np.random.randn(4, 3, 3)
    T = np.einsum('iab,jbc,kca->ijk', A, B, C)   #前面参数 iab 表示 A 每个指标的维数,jbc 表示 B 每个指标的维数,kca 表示 C 每个指标的维数,缩并为 ijk 的张量
    
    print('The shape of the resulting tensor = ')
    print(T.shape)
    

    运行结果如下:
    在这里插入图片描述

    展开全文
  • 其中,二阶张量在形式和性质上与二维矩阵有着高度的一致性,而在CFD中绝大多数情况下所涉及的也都是二阶张量,如笛卡尔坐标系下控制体单元所受到的黏性应力张量 : 可以看出,二阶张量有9个分量,而三阶张量有27个...

    5b7520eb381eccda5acb45d195f2abeb.png

    什么是张量(Tensor)

    张量是基于标量和矢量向更高维度的推广,它通过将一系列具有某种共同特征的数进行有序的组合来表示一个更加广义的“数“。其中,二阶张量在形式和性质上与二维矩阵有着高度的一致性,而在CFD中绝大多数情况下所涉及的也都是二阶张量,如笛卡尔坐标系下控制体单元所受到的黏性应力张量

    可以看出,二阶张量有9个分量,而三阶张量有27个分量,更一般的,n阶张量有

    个分量。在表示各个分量时,如果一个一个的列出来是非常麻烦的,因此通过下标索引符号,如
    ,引入了更为简洁的张量表示法。

    张量表示法(Tensor notation)

    首先,标量在张量表示法中没有下标或者说下标个数为0,如

    。其余张量采用下标索引,其中矢量有一个下标,如
    ;二阶张量有两个下标,如
    ;更一般的,n阶张量有n个下标。在三维笛卡尔坐标系下,下标
    ,则三个坐标轴可以表示为:

    三个方向的速度分量可以表示为:

    1. 自由标

    在张量表示法中,当一个下标符号仅出现一次时,则该下标为自由标,须遍历该下标所有的取值。

    • 如果有且仅有一个自由标,则表示的是矢量,如坐标矢量
      和速度矢量
      可以分别表示为

    这一表示法在前面介绍梯度的文章中已经使用过:

    只要写出

    即可表示等式右边的三个分量,它与
    完全等价,可以根据需要选择书写形式。
    • 当有且仅有两个自由标时,则表示的是二阶张量,如黏性应力
      ,此时我们需要对
      均进行遍历取值,从而得到九项分量:

    再举一例:

    因此只要写出

    即可表示等式右边的九个分量。

    对于更高阶的张量也可依次类推,极大的简化了矢量的表达。

    2. 哑标与爱因斯坦(Einstein)求和约定

    根据爱因斯坦求和约定,当下标重复出现两次时,则对该下标的索引项进行求和,该下标称为哑标

    • 当有且仅有一个哑标时,表示的是一个标量,如前文中介绍的散度表达式:

    上式中由于

    重复了两次,是一个哑标,因此对两个
    同时进行索引,并对其索引项进行求和。

    再举一例:

    • 当有且仅有一个自由标和一个哑标时,自由标和哑标均进行遍历,最终表示的是一个矢量,如:

    上式中,

    为自由标,表示会有三个分量;
    为哑标,表示在每个分量中要进行求和。

    再举一例:

    事实上,自由标的个数决定了该张量的阶数:

    当自由标个数为0时,该张量为0阶,即标量;

    当自由标个数为1时,该张量为1阶,即矢量;

    当自由标个数为2时,该张量为二阶张量;

    依次类推......

    • 当有多个自由标和多个哑标时,张量展开的原则与上述情况相同,只是更加复杂,通常的展开顺序是首先对哑标索引项进行连续展开求和,然后对自由标进行展开,如:

    上式先对两个哑标

    进行了展开,得到九项连续求和。然后可以继续对自由标
    进行展开得到三个分量,因此
    表示的是一个矢量,而且事实上它表示的是流场的旋度
    ,这涉及到符号
    的定义,将在下一篇继续介绍。

    3. 补充说明

    • 张量的表示法中所说的下标个数的统计均是在一个独立的项之内完成的,如
      。通过+/-号连接的表达式不可合并在一起进行展开,比如
      ,这个表达式包含了两个独立的项,应该各自按照规则展开,
      没有任何关系。

    • 如果在一个独立的项中某个下标重复出现了三次或以上呢?说明写错了,张量中不会出现重复三次或以上的下标。

    以上介绍了张量的基本概念和表达法,下一篇将介绍张量的运算。

    参考资料

    张量(物理中力学名称)_百度百科baike.baidu.com
    ddee9299ea55d87da7dcff22279aa2c4.png
    https://farside.ph.utexas.edu/teaching/336L/Fluid/node249.htmlfarside.ph.utexas.edu
    展开全文
  • 这里的叠加系数(波函数) 则是一个二阶张量(tensor),其具有i和j两个指标。同理,如果有A、B和C三个子系统,则有: 那么就得到一个三阶张量 。依次类推,有N个子空间,则可以写成N阶的张量形式。于是,我们可以用...

    对于一个由A和B两个子系统组成的系统,其任意一个态都可以写成下面的形式

    其中

    分别是A和B空间的基。这里的叠加系数(波函数)
    则是一个二阶张量(tensor),其具有i和j两个指标。

    同理,如果有A、B和C三个子系统,则有:

    那么就得到一个三阶张量

    。依次类推,有N个子空间,则可以写成N阶的张量形式。

    于是,我们可以用张量来表示列向量,这对于我们数值计算是非常有帮助的。

    例如,假设有这么一个算符:

    ,其中
    表示B空间的单位矩阵。

    如果我们在数值上要计算这个算符作用在一个态上:

    ,一般是先构造出
    算符的矩阵表示,也就是把
    的矩阵
    直积上一个
    的单位矩阵,得到一个
    维的大矩阵。

    事实上我们可以不用构造出这么一个大矩阵,而是可以利用张量的特点进行计算。例如二阶张量

    的在
    这组基下的矩阵形式为:

    它是一个

    的矩阵。

    这个操作等价于:

    其中

    这组基下的矩阵表示,其是一个
    的矩阵。(具体过程见后文的补充 2)

    于是,我们把一个“

    的矩阵与
    的列向量相乘”的问题转换为了“
    的矩阵与
    的矩阵相乘”这样一个耗费计算资源更少的运算。

    这种计算也称为张量的缩并(Contraction),可以表示成

    这种运算也可以扩展为更高阶张量的计算,这也是Matrix Product State (MPS) 经常用到的一个东西。BTW,在MPS里,张量运算可以用下图来表示:

    30453b7ce5acd5eb3fdcc6a36c3c5259.png

    在这里不打算提太多MPS相关的内容,因为我也不太会,说多错多。。我对MPS的认知仅是从DMRG的角度来的。事实上这俩的原理是差不多的,可以证明DMRG得到的基态是一个MPS。我觉得只要学会DMRG、TEBD、MPS其中之一,再去学另外几个的难度应该是会大大降低的。

    在DMRG中的应用

    OK,铺垫了大半天,现在可以来讲讲怎么应用了。之前笔记2中提到,构造和对角化superblock是一个非常耗费计算资源的过程,因为会涉及到非常多的矩阵乘法。

    有了张量缩并,我们可以不构造superblock来计算基态。首先,我们可以把superblock的哈密顿量拆成这样的形式:

    因此,

    这个操作可以用之前提到的张量缩并,转化成几个小矩阵的乘积以及求和!

    另一方面,有许多求解本征值的算法(例如Davidson算法等)是通过不断迭代矩阵与列矢量的乘法来得到本征值,也就是会涉及到大量的

    的操作,因此我们可以不需要构造superblock来得到基态。

    在这里,MATLAB的eigs() 函数提供了一个很好的方法来帮助我们使用这种技巧,其支持把一个函数句柄作为输入。这个函数句柄是一个自定义的函数,其输入值为一个列向量,返回值则是经过矩阵乘法后的列向量。也就是说MATLAB允许我们对矩阵乘法进行一定的控制,于是我们可以利用这个特性来优化计算superblock基态的过程!

    Full code

    % By Ling Lin @ SYSU, 2020.03.03
    % Running on MATLAB R2019b
    % Version 1.1: Using tensor contraction to enhance the performance
    LatticeLength = 100;
    MaximalStates = 32;
    Dim = 2; % Local dimension
    J=1;
    % Construct Spin operator
    Sx = 1/2 * [0, 1; 1, 0];
    Sy = 1/2 * [0, -1i; 1i, 0];
    Sz = 1/2 * [-1, 0; 0, 1];
    Splus = Sx + 1i* Sy;
    sysBlock.Ham = zeros(length(Sx));
    sysBlock.Splus = Splus;
    sysBlock.Sz = Sz;
    sysBlock.Length = 1;
    
    envBlock.Ham = zeros(length(Sx));
    envBlock.Splus = Splus;
    envBlock.Sz = Sz;
    envBlock.Length = 1;
    
    E_GS = [];
    
    
    while (sysBlock.Length + envBlock.Length) < LatticeLength
        % attach one site respectively onto the sys and env block.
        sysBlock.Ham = kron(sysBlock.Ham, speye(Dim)) ...
            + J/2 * (kron(sysBlock.Splus', Splus) + kron(sysBlock.Splus, Splus')) ...
            + J * kron(sysBlock.Sz, Sz);
        envBlock.Ham = kron(speye(Dim), envBlock.Ham) ...
            + J/2 * (kron(Splus, envBlock.Splus') + kron(Splus', envBlock.Splus)) ...
            + J * kron(Sz, envBlock.Sz);
        
        % Make sure the Hamiltonian is Hermitian
        sysBlock.Ham = (sysBlock.Ham + sysBlock.Ham')/2;
        envBlock.Ham = (envBlock.Ham + envBlock.Ham')/2;
        
        % Obtain the right-most and left-most operator used for connection
        sysBlock.Splus = kron(speye(length(sysBlock.Ham)/Dim), Splus);
        sysBlock.Sz = kron(speye(length(sysBlock.Ham)/Dim), Sz);
        envBlock.Splus = kron(Splus, speye(length(envBlock.Ham)/Dim));
        envBlock.Sz = kron(Sz, speye(length(envBlock.Ham)/Dim));
        sysBlock.Length = sysBlock.Length + 1;
        envBlock.Length = envBlock.Length + 1;
        
        % Implement the tensor contraction instead of constructing superblock
        Tensor = HamTensorContraction();
        Tensor.J = J;
        Tensor.sysBlock = sysBlock;
        Tensor.envBlock = envBlock;
        [Psi_GS, E_GS0] = eigs(@Tensor.tensorContraction, ...
            length(sysBlock.Ham) *length(envBlock.Ham), 1, 'sr');
        E_GS = [E_GS, E_GS0/(sysBlock.Length + envBlock.Length)];
    
        % Carry out the partial trace
        [sysBlock.DM, envBlock.DM] = ptrace(Psi_GS, length(sysBlock.Ham), length(envBlock.Ham));
        
        % Make sure the reduced density matrix is Hermitian
        sysBlock.DM = (sysBlock.DM + sysBlock.DM')/2;
        envBlock.DM = (envBlock.DM + envBlock.DM')/2;
        
        % Diagonalize the reduced density matrix
        [sysBlock.rotationMatrix, sysBlock.weight] = eig(sysBlock.DM);
        [envBlock.rotationMatrix, envBlock.weight] = eig(envBlock.DM);
        [sysBlock.weight, Isys] = sort(diag(sysBlock.weight), 'descend');
        [envBlock.weight, Ienv] = sort(diag(envBlock.weight), 'descend');
        
        % Obtain the truncated basis
        sysBlock.rotationMatrix = sysBlock.rotationMatrix(:, ...
            Isys(1:min(MaximalStates, length(sysBlock.rotationMatrix))));
        envBlock.rotationMatrix = envBlock.rotationMatrix(:, ...
            Ienv(1:min(MaximalStates, length(envBlock.rotationMatrix))));
        
        % Rotate (truncate) to the new basis
        sysBlock = rotate2NewBasis(sysBlock);
        envBlock = rotate2NewBasis(envBlock);
        
        fprintf('Total length = %dn', sysBlock.Length + envBlock.Length)
    end
    %%
    figure;
    plot(E_GS, 'o', 'disp', 'DMRG')
    hold on
    plot(1:length(E_GS), repmat(1/4-log(2), length(E_GS), 1), 'k', 'disp', 'Exact')
    xlabel('Loop times')
    ylabel('Energy')
    legend
    %%
    function [DM1, DM2] = ptrace(psi, dim1, dim2)
    % Perform the partil trace and obtain two reduced density matrix
    rho = reshape(psi, dim2, dim1);
    DM2 = rho * rho';
    DM1 = rho' * rho;
    end
    
    function Block = rotate2NewBasis(Block)
    % Perform the rotation to the truncated basis
    Block.Ham = Block.rotationMatrix' * Block.Ham * Block.rotationMatrix;
    Block.Splus = Block.rotationMatrix' * Block.Splus * Block.rotationMatrix;
    Block.Sz = Block.rotationMatrix' * Block.Sz * Block.rotationMatrix;
    end
    
    
    

    以及一个class (命名为HamTensorContraction.m 并放在同一个目录下):

    % Used for performing the tensor contraction
    classdef HamTensorContraction
        properties
            sysBlock;
            envBlock;
            J;
        end
        methods
            function outputVector = tensorContraction(obj, inputVector)
                % transform the column vector into tensor
                outputVector = reshape(inputVector, ... 
                    length(obj.envBlock.Ham), length(obj.sysBlock.Ham)); 
                
                % tensor contraction
                outputVector = obj.envBlock.Ham * outputVector ...
                    + outputVector * obj.sysBlock.Ham ...
                    + obj.J/2 * (obj.envBlock.Splus' * outputVector * (obj.sysBlock.Splus).'...
                    + obj.envBlock.Splus * outputVector * (obj.sysBlock.Splus').') ...
                    +  obj.J * obj.envBlock.Sz * outputVector * (obj.sysBlock.Sz).';
                
                % transform back to column vector
                outputVector = outputVector(:);
            end
        end
    end

    运算结果与之前一致。

    后记

    大家可以对比一下,增加所保留的态的数量(MaximalStates),这两种算法的运算速度差异有多大(MaximalStates=64时,未优化的算法在我的小破本上已经是龟速,而优化后的算法则有明显提升)。

    • 需要注意的是,在MATLAB里,我所使用的tensor和上文提到的tensor差了一个转置的关系,所以env的矩阵是左乘,sys的矩阵则是转置后右乘。

    补充 1 关于partial trace

    两个列向量的直积会得到如下的结果:

    也即得到一个

    维的列向量。通过reshape()函数,我们可以把列向量变成一个
    的矩阵:

    很容易可以证明:

    如果弄明白了上面这几步,那么相信大家对这里的张量会有更深的理解。

    补充2 张量缩并

    对于态:

    当作用

    时,有:

    这个过程中插入了完备基

    于是,我们发现对于这样的运算,我们只需要计算

    即可,也就是前文所提到的张量缩并。

    数值上,我们可以先把列矢量通过reshape()函数变成一个张量(注意reshape后张量的指标),然后作用在不同子空间上的哈密顿量即可用上面推导的结论进行计算。

    展开全文
  • 综述 TensorFlow使用张量来表示数据并且在各个节点之间进行运算   阶(Ranks) ...可以认为一个二阶张量就是我们平常所说的矩阵,一阶张量可以认为是一个向量。对于一个二阶张量你可以用语...

    综述

    TensorFlow使用张量来表示数据并且在各个节点之间进行运算

     

    阶(Ranks)

    TensorFlow系统中,张量的维数来被描述为阶。下面的张量(使用Python中list定义的)就是2阶.

        t = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    可以认为一个二阶张量就是我们平常所说的矩阵,一阶张量可以认为是一个向量。对于一个二阶张量你可以用语句t[i, j]来访问其中的任何元素。而对于三阶张量你可以用't[i, j, k]'来访问其中的任何元素

     

     

    表格:

    数学实例 Python 例子
    0 纯量 (只有大小) s = 483
    1 向量(大小和方向) v = [1.1, 2.2, 3.3]
    2 矩阵(数据表) m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    3 3阶张量 (数据立体) t = [[[2], [4], [6]], [[8], [10], [12]], [[14], [16], [18]]]
    n n阶 (自己想想看) ....


     

    形状(shape)

    一个形状的表示你可以用't[i, j, k]'来访问其中的任何元素就是张量的一个维度,一个形状的表示,比如说[[3,3]] 使用get_shape()后得到的是(2,1),也就是在以为上是两维:3,3

    在二维上只有一个[3,3]

     

     

    数据类型 (type)

     

    除了维度,Tensor有一个数据类型属性.你可以为一个张量指定下列数据类型中的任意一个类型:

    数据类型 Python 类型 描述
    DT_FLOAT tf.float32 32 位浮点数.
    DT_DOUBLE tf.float64 64 位浮点数.
    DT_INT64 tf.int64 64 位有符号整型.
    DT_INT32 tf.int32 32 位有符号整型.
    DT_INT16 tf.int16 16 位有符号整型.
    DT_INT8 tf.int8 8 位有符号整型.
    DT_UINT8 tf.uint8 8 位无符号整型.
    DT_STRING tf.string 可变长度的字节数组.每一个张量元素都是一个字节数组.
    DT_BOOL tf.bool 布尔型.
    DT_COMPLEX64 tf.complex64 由两个32位浮点数组成的复数:实数和虚数.
    DT_QINT32 tf.qint32 用于量化Ops的32位有符号整型.
    DT_QINT8 tf.qint8 用于量化Ops的8位有符号整型.
    DT_QUINT8 tf.quint8 用于量化Ops的8位无符号整型.

     

     

    展开全文
  • 向量/矩阵/张量向量向量可以表示成一维数组,每个分量可以理解为向量所表示的点在空间中坐标的分量。矩阵矩阵可以表示成二维数组,上...二阶张量矩阵概念不同,但可以建立联系,矩阵可以描述二阶张量的一些特性(在确
  • 张量 TensorFlow名字可以拆解为两部分:Tensor、Flow。其中,Tensor 就表示张量。 在 TensorFlow 的世界里...二阶张量表示矩阵(matrix),也就是一个二维数组;n阶张量表示n维数组。 与Python numpy中多维数组不同...
  • 张量(Tensor)张量是矢量和矩阵概念的推广,标量是0阶张量,矢量是1阶张量,矩阵二阶张量,而三阶张量好比是立方体矩阵。张量是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的...
  • 张量与张量网络 ...上面这个图从左到右分别表示:一阶张量、二阶张量以及三阶张量,我们可以看出,一个张量的阶数在图像化的表示中被抽象称为了张量的腿的数量,而中间的方形或者圆形则表示张量本身。实际上
  • 通俗理解张量tensor

    2019-02-14 13:03:33
    几何代数中定义的张量是基于向量和矩阵的推广,通俗一点理解的话,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。   定义 张量的严格定义是利用线性映射来描述的。与矢量相类似,定义...
  • 张量:几何代数中的张量是基于向量和矩阵的推广,通俗一点理解,我们可以将标量视为零阶张量,矢量视为一阶张量,矩阵就是二阶张量。 也就是说,我们可以将张量理解为n维数组。在Tensorflow中,张量其实就是tensor。...
  • 从功能角度看,张量可理解...二阶张量矩阵,也就是二维数组。eg. c=[[1,2],[3,4],[5,6]] n阶张量可理解为n维数组。 简单记法:左边有多少个中括号"["就是多少阶。 张量的形状(shape)是每个维度中元素...
  • 数学中定义的张量是基于向量和矩阵的推广,换而言之,标量可视为零阶张量,矢量可视为一阶张量,矩阵可视为二阶张量。在pytorch中,张量Tensor是最基础的运算单位,与NumPy中的NDArray类似,张量表示的是一个多维...
  • 张量(Tensor)几何代数中定义的张量是基于向量和矩阵的推广,通俗一点来理解,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。张量在PyTorch中,张量Tensor是最基础的运算单位,与NumPy中的...
  • 张量(Tensor)几何代数中定义的张量是基于向量和矩阵的推广,通俗一点来理解,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。张量在PyTorch中,张量Tensor是最基础的运算单位,与NumPy中的...
  • 上面的是二阶张量积的9个基。 矩阵表示里面应该是个有9个子矩阵的大矩阵。每个子矩阵是如果是3×3的。那么整个矩阵是9×9的。 上面是三阶张量积的27个基,期中上面9个的右下角应该是三个竖着的棒,您看出来了...
  • 一、张量的阶和数据类型 TensorFlow用张量这种数据结构来表示所有的数据.一个张量有一个静态...一个二阶张量就是我们平常所说的矩阵,一阶张量可以认为是一个向量. 阶 数学实例 Python 例子 0 纯量 (只有...
  • 通俗理解张量(Tensor)

    2020-05-07 23:07:04
    通俗理解张量tensor江湖人称冷不丁关注22018.07.20 17:20:26字数 1,500...几何代数中定义的张量是基于向量和矩阵的推广,通俗一点理解的话,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。 ...
  • 张量概念及基本运算

    万次阅读 2018-11-04 20:50:59
    二阶张量:matrix 例如用户对电影评价表,每行表示一个用户,每列表示一部电影。矩阵中的值表示评价值。 三阶张量:例如上例中再加一个时间维度。还如用户关注某个主题的名人,每个值为1表示该用户关注了某主题下...
  • 在数学里,张量(Tensor)是一种“几何实体”,拥有“不依赖于参照系的...二维欧式空间中的点是几何的,但是要用x、y两个坐标系(基)来表示,那二阶张量便与矩阵(代数)对应起来,同理三维欧式空间中的点也是如此。
  • 1、tensorflow数据模型——张量在tensorflow中所有的数据都通过张量的...例如,[2, 3, 5, 7, 11] 或 [5]矩阵是二维数组(二阶张量)。例如,[[3.1, 8.2, 5.9][4.3, -2.7, 6.5]]张量可以作为常量或变量存储在图中...
  • 每个张量的维度单位用阶来描述,零阶张量是一个标量,一阶张量是一个向量,二阶张量是一个矩阵 所以标量、向量(矢量)和矩阵等都是特殊类型的张量 TensorFlow 支持以下三种类型的张量: 1、常量:常量是其值不能改变的...
  •   这里将一个三阶张量分解成了两个二阶张量和若干个三阶张量的乘积,如果我们用等式来表达这个过程会显得麻烦,此时,新的方法就起到了作用。 定义:给定一个N阶张量,如果能将其分解成N个二阶或
  • 该张量网络由三种不等价张量构成,在四个角上的张量为二阶张量,在边上的张量为三阶张量,在内部的张量为四阶张量。 TEBD算法为一种基于矩阵乘积态的、近似收缩张量网络的数值算法。从处于边界的张量构成的MPS开始,...
  • TensorFlow用张量这种数据结构来表示所有的数据。用一阶张量来表示向量,如:v = [1.2, 2.3, 3.5] ,如二阶张量表示矩阵,如:m = [[1, 2, 3], [4, 5, 6],
  • 矩阵相乘的实现方法

    2020-05-24 11:17:40
    目前不论是基于pytorch还是tensorflow的深度学习框架,数据的表示基础就是tensor,也就是张量,二阶张量中就包含着矩阵;众所周知,矩阵乘法:矩阵相乘最重要的方法是一般矩阵乘积。本文章内容也只谈论一般矩阵乘积...
  • Tensorflow 中的矩阵和向量

    千次阅读 2018-08-31 11:13:50
    真的很粗心啊!!刚玩Tensorflow总是会犯这种低级错误! ... 只要明确如下两句话基本可以摆脱这种小毛病。...2.一个二阶张量就是我们平常所说的矩阵,一阶张量可以认为是一个向量。 如果不细心就总...
  • 《张量分解与应用》第一二章翻译:张量是一种多维数组。一个一阶张量就是一个向量,一个二阶张量是一个矩阵,具有三阶或更多阶数的张量称为高阶数组。... 矩阵二阶张量)用粗体大写字母表示,如.
  • 几何代数中定义的张量是基于向量和矩阵的推广,通俗一点理解的话,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。 三阶张量 shape(m,n,k),可以理解为k个大小为(m,n)的二阶张量(想像二...
  • tensorflow 学习笔记(三) - 入门基础 TensorFlow用张量(tensor)这种数据结构来表示所有的数据。...二阶张量表示矩阵,如:m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 可以看成是方括号嵌套的层数。

空空如也

空空如也

1 2 3 4
收藏数 65
精华内容 26
关键字:

二阶张量矩阵表示