您的位置:新葡亰496net > 电脑系统 > 新葡亰496net:矩阵快捷幂小结,机器学习中的线

新葡亰496net:矩阵快捷幂小结,机器学习中的线

发布时间:2019-11-16 11:29编辑:电脑系统浏览(164)

     

    在本篇开首前,先向大家推荐一本书:《3D数学底子:图形与娱乐开辟》
    那本书累累游玩相关的数学知识都讲得超细,值得生龙活虎看。早前学的事物重重都还给老师了,啃那本书,补回了在此以前的多多文化啊!(自个儿数学渣,看那本书费了点时间,万幸以前学过,能懂在讲怎么着。。。卡塔 尔(英语:State of Qatar)

    第二章 机器学习中的线性代数知识

    线性代数作为数学中的二个最主要的道岔,广发应用在不利与工程中。精通好线性代数对于领悟和从业机械学习算法相关的做事是很有必要的,特别是对于深度学习而言。因而,在开首介绍深度学习早前,先集中钻探一些必备的线性代数知识。

    update in 9.17

    展开药方法

    故事情节部分先不用管,笔者那边只是做个测量试验,过几天会讲这几个的,先忽视

    新葡亰496net 1


     

     

     

    2.矩阵专辑¶

    作弄一下:矩阵本人简单,不过矩阵的作文太蛋疼了 (⊙﹏⊙)汗 还好有Numpy,不然真的崩溃了...

    LaTex有未有叁个集成了成都百货上千常用公式以及推导或者含题库的在线编辑器?

    代码裤子:

    在线编制程序系:

    数学根底:

    Numpy基础:

    在线预览:http://github.lesschina.com/python/ai/math/矩阵专栏.html

    本作品面向的指标是有3D数学功底不过由于长日子没接触变生疏,或对少数知识点理解尚反常的人群。

    2.1 标量,向量,矩阵和张量

    标量(scalar):二个标量就是一个单身的数。用斜体表示标量,如 $s in R$.

    向量(vector):多少个向量是一列数,大家用粗体的小写名称表示向量。比如$bf x$,将向量$bf x$ 写成方括号包括的纵柱:
    $$
    {bf x}= begin {bmatrix} x_1x_2 vdots x_n end{bmatrix}
    $$
    矩阵(matrix):矩阵是二维数组,大家何奇之有授予矩阵粗体大写变量名称,比方$bf A​$ 。若是一个矩阵中度是$m​$,宽度是$n​$,那么说$bf Ain bf R ^{m times n}​$ 。三个矩阵能够代表如下:
    $$
    {bf A}= begin{bmatrix} x_{11} &x_{12} x_{21} & x_{22} end{bmatrix}
    $$
    张量(tensor):有些意况下,我们会商量持续维坐标的数组。假设大器晚成组数组中的成分布满在多少维坐标的国有国法互联网中,就将其名称为张量。用$bf A​$ 表示,如张量中坐标为$(i,j,k)​$的成分记作${bf A}_{i,j,k}​$。

    转置(transpose):矩阵的转置是以对角线为轴的镜像,那条从左上角到右下角的对角线称为主对角线(main diagonal卡塔 尔(阿拉伯语:قطر‎。将矩阵$bf A$的转置表示为${bf A^top}$。定义如下:
    $$
    ({bf A^top}){i,j}=bf A{j,i}
    $$

    $$
    {bf A} = begin{bmatrix} x_{11} &x_{12} x_{21} & x_{22} x_{31} & x_{32} end{bmatrix} implies {bf A^top}= begin{bmatrix} x_{11} &x_{21}&x_{31} x_{21} & x_{22}& x_{32} end{bmatrix}
    $$

    矩阵

    并不想扯什么高档线代的剧情因为自个儿也不会

    矩阵类别¶

    2.1.矩阵的概念¶

    矩阵:是一个据守长方阵列排列的复数或实数集合。

    深入显出讲正是:把数排成m行n列后,然后用中括号把它们括住,这种样式的构成正是矩阵了~ eg:

    $begin{bmatrix} &a_{11}&a_{12}&a_{13}&...&a_{1n} \ &a_{21}&a_{22}&a_{23}&...&a_{2n} \ &a_{31}&a_{32}&a_{33}&...&a_{3n} \ &vdots&vdots&vdots&ddots&vdots\ &a_{m1}&a_{m2}&a_{m3}&...&a_{mn} \ end{bmatrix}$

    比方说上边那几个示例正是四个m × n的矩阵(m行n列的矩阵卡塔尔,假使m=n那么就叫做n阶方阵,eg:

    $begin{bmatrix} 1&2&3 \ 4&5&6 \ 7&8&9 end{bmatrix}$

    那几个正是3阶方阵


    借使回去中学,老师显著都以由此三遍方程组来引进矩阵(逆天的教育工作者是那样讲的卡塔 尔(阿拉伯语:قطر‎:

    $begin{cases}x_1 x_2=-1\2x_1-x_2=4\3x_1 5x_2=-7\end{cases}$ ==> $begin{bmatrix}1&1\2&-1\3&5end{bmatrix}begin{bmatrix}x_1\x_2end{bmatrix}=begin{bmatrix}-1\4\-7end{bmatrix}$

    即使您方程组都记不清怎么解的话...好吧还是说下呢:“举个例子这题,能够先把x2移到右边手,这样x1就约等于一个表明式了(x1=-x2-1卡塔 尔(阿拉伯语:قطر‎,然后带入第一个表明式就能够解出x1和x2了,三次的实在七个表达式就足以解出了,剩下的您能够把值带进去验证一下”


    2.2 矩阵和向量相乘

    矩阵乘法是矩阵运算中最要紧的操作之大器晚成。八个矩阵$bf A$和$bf B$ 的矩阵乘积(matrix product)是第二个矩阵$bf C$ 。矩阵乘法中$bf A$ 的列必得和 $bf B$ 的行数相仿。即假设矩阵 $bf A$ 的样子是 $m times n$ ,矩阵 $bf B$ 的形象是 $n times p$ ,那么矩阵 $bf C$ 的形状便是$m times p$ 。即
    $$
    bf C = bf A times bf B
    $$
    切实的地,此中的乘法操作定义为
    $$
    {bf C}{i,j} = sum_k {bf A}{i,k} {bf B}_{k,j}
    $$
    矩阵乘积遵守分配律
    $$
    bf A(B C) = bf AB AC
    $$
    矩阵乘积也听从结合律
    $$
    bf A(BC) = (AB)C
    $$
    专心:矩阵乘积未有交流律

    点积(dot product)多个相像维数的向量$bf x$ 和 $bf y$ 的点积可看做是矩阵乘积 $bf xtop y$

    矩阵乘积的转置
    $$
    (bf AB)top = B top Atop
    $$
    选用向量的乘积是标量,标量的转置是本身的真相,我们得以评释(10卡塔 尔(阿拉伯语:قطر‎式:
    $$
    bf x top y = (xtop y)top = ytop x
    $$
    线性方程组
    $$
    bf Ax = b
    $$

    定义

    由$n times m$个数$a_{ij}$排成的$n$行$m$列的数表称为$n$行$m$列的矩阵,简单的称呼$n times m$矩阵。

    $$
    A =
    begin{bmatrix}
    a_{11} & a_{12} & dots a_{1m} \
    a_{21}, & dots & dots \
    a_{31}, & dots & dots \
    a_{41} & dots & a_{nm}
    end{bmatrix}
    $$

    1.成立特殊矩阵¶

    2.2.矩阵的演算(含幂运算卡塔 尔(英语:State of Qatar)¶

    坐标系

    首先要讲的是坐标系,在3D中,坐标系类型有那些,超重大的是3D坐标系,常见的分三种:左臂坐标系和侧边坐标系,首要差异是Z轴的方向(我们定义X轴私下认可正方向为右,Y轴暗中同意正方向为上卡塔尔国,左臂系Z轴正方向为指向显示器中间,右臂系Z轴正方向为指向显示器表面:

    新葡亰496net 2

    左边系 (图截自《3D数学底子:图形与游戏支付》卡塔尔国

    新葡亰496net 3

    右边系 (图截自《3D数学根基:图形与游乐支付》卡塔 尔(阿拉伯语:قطر‎

    Ps:在Unity中,暗许使用的是左侧坐标系(摄像机的侦查空间(以录制机为原点的坐标系卡塔 尔(阿拉伯语:قطر‎除却卡塔尔。

    在贰个空间中,有了坐标系的留存,就能够规定空间中物体的具体地方。

    2.3 单位矩阵和逆矩阵

    线性代数中提供了 矩阵逆(matrix inverse) 的工具,使得大家能够剖判地求解(11卡塔 尔(英语:State of Qatar)中的 $bf A$.

    单位矩阵(identity matrix卡塔尔:自便向量与单位矩阵相乘都不会变动。我们将维持 $n$ 维向量不改变地单位矩阵记作为 $bf I_n$ ,形式上 $bf I_n in Bbb R ^{ntimes n}$ ,
    $$
    forall bf x in Bbb R^n, bf I_nx=x
    $$
    矩阵 $bf A$ 的矩阵逆被记作 $bf A^{-1}$ ,被定义为如下方式:
    $$
    bf A{-1}A=AA{-1}=I_n
    $$
    (11卡塔 尔(阿拉伯语:قطر‎式方程组的求解:
    $$
    bf Ax = b
    A^{-1}Ax = A^{-1}b
    I_n x=A^{-1}b
    x = A^{-1}b
    $$
    方程组的解决议于能或不能够找到二个逆矩阵 $bf A^{-1}$ 。接下来商量逆矩阵 $bf A^{-1}$ 的留存的标准化。

    运算

    这里只讲加法减法和乘法,其余的譬如矩阵求逆等与本文内容出入一点都不小,风野趣的能够团结攻读

    1.1.成立全为0的矩阵¶

    np.zeros(tuple)

    $$begin{bmatrix} 0&0&0 \ 0&0&0 \ 0&0&0 end{bmatrix}$$

    In [1]:

    import numpy as np
    

    In [2]:

    help(np.zeros)
    

     

    Help on built-in function zeros in module numpy.core.multiarray:
    
    zeros(...)
        zeros(shape, dtype=float, order='C')
    
        Return a new array of given shape and type, filled with zeros.
    
        Parameters
        ----------
        shape : int or sequence of ints
            Shape of the new array, e.g., ``(2, 3)`` or ``2``.
        dtype : data-type, optional
            The desired data-type for the array, e.g., `numpy.int8`.  Default is
            `numpy.float64`.
        order : {'C', 'F'}, optional
            Whether to store multidimensional data in C- or Fortran-contiguous
            (row- or column-wise) order in memory.
    
        Returns
        -------
        out : ndarray
            Array of zeros with the given shape, dtype, and order.
    
        See Also
        --------
        zeros_like : Return an array of zeros with shape and type of input.
        ones_like : Return an array of ones with shape and type of input.
        empty_like : Return an empty array with shape and type of input.
        ones : Return a new array setting values to one.
        empty : Return a new uninitialized array.
    
        Examples
        --------
        >>> np.zeros(5)
        array([ 0.,  0.,  0.,  0.,  0.])
    
        >>> np.zeros((5,), dtype=int)
        array([0, 0, 0, 0, 0])
    
        >>> np.zeros((2, 1))
        array([[ 0.],
               [ 0.]])
    
        >>> s = (2,2)
        >>> np.zeros(s)
        array([[ 0.,  0.],
               [ 0.,  0.]])
    
        >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
        array([(0, 0), (0, 0)],
              dtype=[('x', '<i4'), ('y', '<i4')])
    

    In [3]:

    # 一维
    np.zeros(5) # 完整写法:np.zeros((5,))
    

    Out[3]:

    array([0., 0., 0., 0., 0.])
    

    In [4]:

    # 可以指定类型
    np.zeros(5,dtype=int)
    

    Out[4]:

    array([0, 0, 0, 0, 0])
    

    In [5]:

    # 二维
    np.zeros((2,5))
    

    Out[5]:

    array([[0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.]])
    

    In [6]:

    # 三维 ==> 可以这么理解,2个2*5(2行5列)的矩阵
    np.zeros((2,2,5))
    

    Out[6]:

    array([[[0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.]],
    
           [[0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.]]])
    

    In [7]:

    ################### 扩展部分 ########################
    

    In [8]:

    # 建议用元组,官方文档都是元组,而且shape返回类型就是元组
    array1 = np.zeros([2,3])
    print(array1)
    type(array1)
    print(array1.shape) # shape返回类型就是元组
    

     

    [[0. 0. 0.]
     [0. 0. 0.]]
    (2, 3)
    

     

    2.2.1.加、减¶

    加减比较轻巧,就是对应成分相加减 (只有行列都相同的矩阵才方可拓宽)

    就绝不麻烦的LaTex后生可畏行行打了,我们用更方便人民群众的 NumPy 来演示一下矩阵加法(不懂代码的直白看结果,不影响阅读的)

    Numpy有特地的矩阵函数(np.mat卡塔尔国,用法和ndarray差不多,我们那边使用平常选拔ndarray花色,底工忘记了足以去查看一下:Numpy基础

    扩展:矩阵的加法运算满意交流律:A B = B A (乘法特别)

    In [1]:

    import numpy as np
    

    In [2]:

    # 创建两个集合
    A = np.arange(1,10).reshape((3,3))
    B = np.arange(9).reshape((3,3))
    
    print(A)
    print("-"*5)
    print(B)
    

     

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    -----
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    

    In [3]:

    # 加法
    A   B
    

    Out[3]:

    array([[ 1,  3,  5],
           [ 7,  9, 11],
           [13, 15, 17]])
    

    In [4]:

    # 和A B相等
    B   A
    

    Out[4]:

    array([[ 1,  3,  5],
           [ 7,  9, 11],
           [13, 15, 17]])
    

    In [5]:

    # 减法
    A - B
    

    Out[5]:

    array([[1, 1, 1],
           [1, 1, 1],
           [1, 1, 1]])
    

    In [6]:

    ################ 变化来了 ################
    

    In [7]:

    # 之前说过 ”只有行列都相同的矩阵才可以进行“ 来验证一下
    # 创建一个2行3列的矩阵
    C = np.arange(6).reshape((2,3))
    D = np.arange(6).reshape((3,2))
    
    print(C)
    print("-"*5)
    print(D)
    

     

    [[0 1 2]
     [3 4 5]]
    -----
    [[0 1]
     [2 3]
     [4 5]]
    

    In [8]:

    # 2行3列的矩阵   3行2列的矩阵
    C   D # 不同形状的矩阵不能进行加运算
    

     

    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-8-bc97e29f7e31> in <module>()
          1 # 2行3列的矩阵   3行2列的矩阵
    ----> 2C   D # 不同形状的矩阵不能进行加运算
    
    ValueError: operands could not be broadcast together with shapes (2,3) (3,2) 
    

    In [9]:

    C - D # 不同形状的矩阵不能进行减运算
    

     

    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-9-ca5169d0bf6c> in <module>()
    ----> 1C - D # 不同形状的矩阵不能进行减运算
    
    ValueError: operands could not be broadcast together with shapes (2,3) (3,2) 
    

     

    向量

    向量首先要跟标量区分:向量具备可行性和分寸等概念,而标量独有大小。在Unity中常用的向量有法线、切线等。

    在象征方式上,向量能够用三个风姿罗曼蒂克维数组意味着,比如:
    ![][1]
    [1]:http://latex.codecogs.com/png.latex?a=begin{bmatrix}1&2&3end{bmatrix}

    ![][2]
    [2]:http://latex.codecogs.com/png.latex?a=begin{bmatrix}123end{bmatrix}
    横向书写的称之为行向量,竖向书写的称之为列向量,向量中的每三个重量对应于其n维空间中的分量,上例中分占的额数为x、y、z,至于在使用时是用行依然列,要基于实际景况来显明。(前面会涉嫌卡塔尔国
    而在情理中,向量具备其实际意义:比方上述的a向量,表示由多少个点到其它贰个点位移,上式中,表示点A向x方向活动1个单位,y方向移动2个单位,z方向运动3个单位到达点B。(注意,在坐标系中,位移未有现实的岗位,能够在恣意地点表示,只象征位移量和取向卡塔 尔(阿拉伯语:قطر‎

    2.4 线性相关和生成子空间

    设若逆矩阵 $bf A^{-1}$ 存在,那么(11卡塔 尔(阿拉伯语:قطر‎式明显对于每三个向量 $bf b$ 恰恰存在三个解。分析方程有多少个解,大家能够看作是 $bf A$ 的列向量的 线性组合(linear combination卡塔 尔(英语:State of Qatar)
    $$
    {bf Ax} = sum_i x_i {bf A}_{:,i}
    $$
    情势上,有个别群集中向量的线性组合,是指每种向量乘以对应系数之后的和,即
    $$
    sum_i c_i {bf v}^{(i)}
    $$
    风流罗曼蒂克组向量的转换空间(span) 是原本向量线性组合后所能抵达的点的聚合。

    线性毫不相关(linearly independent卡塔尔: 假若风流倜傥组向量中的放肆三个向量都不可能代表成其它向量的线性组合,那么那组向量被喻为线性无关

    要想使矩阵可逆,首先必需矩阵是三个方阵(square卡塔尔国,即 $m=n$ ,其次,全数的列向量都以线性非亲非故的。

    二个列向量线性相关的方阵被称为 奇异的(singular)

    加法

    在意,唯有行列均意气风发致的矩阵才有加法!

    运算也比较简单,把对应地方的数相加得到四个新的矩阵,即为答案

    例如

    $$
    begin{bmatrix} 1 & 1 & 2 \ 1 & 0 & 1 end{bmatrix}

    • begin{bmatrix} 2 & 3 & 3 \ 3 & 3 & 2 end{bmatrix}

      begin{bmatrix} 3 & 4 & 5 \ 4 & 3 & 3 end{bmatrix}
      $$

    加法满意以下运算律

    $A B = B A$

    $ C = A $

    1.2.创制全为1的矩阵¶

    np.ones(tuple) 用法和np.zeros(tuple)差不多

    $$begin{bmatrix} 1&1&1 \ 1&1&1 \ 1&1&1 end{bmatrix}$$

    In [9]:

    help(np.ones)
    

     

    Help on function ones in module numpy.core.numeric:
    
    ones(shape, dtype=None, order='C')
        Return a new array of given shape and type, filled with ones.
    
        Parameters
        ----------
        shape : int or sequence of ints
            Shape of the new array, e.g., ``(2, 3)`` or ``2``.
        dtype : data-type, optional
            The desired data-type for the array, e.g., `numpy.int8`.  Default is
            `numpy.float64`.
        order : {'C', 'F'}, optional
            Whether to store multidimensional data in C- or Fortran-contiguous
            (row- or column-wise) order in memory.
    
        Returns
        -------
        out : ndarray
            Array of ones with the given shape, dtype, and order.
    
        See Also
        --------
        zeros, ones_like
    
        Examples
        --------
        >>> np.ones(5)
        array([ 1.,  1.,  1.,  1.,  1.])
    
        >>> np.ones((5,), dtype=int)
        array([1, 1, 1, 1, 1])
    
        >>> np.ones((2, 1))
        array([[ 1.],
               [ 1.]])
    
        >>> s = (2,2)
        >>> np.ones(s)
        array([[ 1.,  1.],
               [ 1.,  1.]])
    

    In [10]:

    # 一维
    np.ones(5) # 完整写法 np.ones((5,))
    

    Out[10]:

    array([1., 1., 1., 1., 1.])
    

    In [11]:

    # 可以指定类型
    np.ones(5,dtype=int)
    

    Out[11]:

    array([1, 1, 1, 1, 1])
    

    In [12]:

    # 二维,传一个shape元组
    np.ones((2,5))
    

    Out[12]:

    array([[1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1.]])
    

    In [13]:

    # 三维 可以理解为两个二维数组
    np.ones((2,2,5))
    

    Out[13]:

    array([[[1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1.]],
    
           [[1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1.]]])
    

     

    2.2.2.数乘、数除¶

    以此也比较容易,就是和各类元素相乘,eg:2×A,A原来的每二个因素都扩充了两倍

    数除其实正是乘以尾数(1/x卡塔 尔(英语:State of Qatar)

    In [10]:

    print(A)
    

     

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    

    In [11]:

    # 比如2×A,A原本的每一个元素都扩大了两倍
    2 * A
    

    Out[11]:

    array([[ 2,  4,  6],
           [ 8, 10, 12],
           [14, 16, 18]])
    

    In [12]:

    print(A)
    

     

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    

    In [13]:

    # 友情提醒:Numpy里面的运算基本上都是针对每一个元素
    A / 2
    

    Out[13]:

    array([[0.5, 1. , 1.5],
           [2. , 2.5, 3. ],
           [3.5, 4. , 4.5]])
    

     

    向量运算

    向量尺寸:向量的轻重也称之为向量的模,表示位移量的高低,以3维向量为例:
    ![][1]
    [1]:http://latex.codecogs.com/png.latex?a=begin{bmatrix}1&2&3end{bmatrix}
    该向量的大大小小总括为:
    ![][3]
    [3]:http://latex.codecogs.com/png.latex?left|aright|=sqrt{12 22 3^2}
    即为两点间的离开公式
    在Shader中,大家平日要将向量规范化(也可以称作归意气风发化卡塔尔,也正是把向量的大小置为1,在坐标系中能够知晓为以叁个点为圆(球卡塔尔心,半径为1的二个圆(球卡塔尔国
    条件公式如下:
    ![][4]
    [4]:http://latex.codecogs.com/png.latex?a_{normal}=frac{a}{left|aright|}

    新葡亰496net 4

    单位圆 (图截自《3D数学功底:图形与娱乐支付》卡塔尔国

    2.5 范数

    有的时候候大家要求衡量四个向量的轻重,在机器学习中,大家使用称为范数(norm)的函数来衡量矩阵大小,格局上, $L^p$ 范数如下:
    $$
    ||{bf x}||_p = (sum_i |x_i|p)frac{1}{2}
    $$
    其中 $p in Bbb R, p geq 1​$。

    范数是将向量映射到非负值的函数。直观上来讲,向量 $bf x$ 的范数正是衡量从原点到 $bf x$ 的比喻。更严酷来讲,范数满意下列性质的函数:

    • ${bf f(x)}=0 implies {bf x} =0$
    • ${bf f(x y)} leq {bf f(x)} {bf f(y)}$
    • $forall alpha in Bbb R, bf f(alpha {bf x}) = |alpha|f({bf x})$

    当 $p=2$ 时, $L^2$ 被称作 欧几里得范数(Euclidean norm卡塔 尔(英语:State of Qatar)。它表示从原点出发到向量 $bf x$ 鲜明的点的欧几里得间距。平方 $L^2$ 范数常被用来衡量向量的大大小小,因为它有扶持求导计算(如对向量中各种成分的导数只在于对应的成分,可是它也可以有劣势,即它在原点相近增加得十一分悠悠卡塔尔国,能够简轻巧单用点积 $ bf x top x$ 来计算。

    max 范数(max norm):那些范数表示向量中存有最小幅面得元素的断然值,用 $L^infty$ 范数表示,期格局为:
    $$
    ||{bf x}||infty = sqrt {sum{(i,j)} {bf A}^ 2_{i,j}}
    $$
    多少个向量的点积(dot product)也得以用范数来表示。具体地,
    $$
    bf x top y = ||x||_2||y||_2 cos theta
    $$

    减法

    与加法同理。

    1.3.单位矩阵¶

    先广泛叁个数学底工:任何矩阵 x 单位矩阵 都等于其本身

    单位矩阵是个方阵,从左上角到右下角的对角线(称为主对角线卡塔 尔(阿拉伯语:قطر‎上的要素均为1。其余全都为0,eg:

    $$begin{bmatrix} 1&0&0 \ 0&1&0 \ 0&0&1 end{bmatrix}$$

    np.eye() 来定义(eye:眼睛)

    扩展:np.eye(rows,columns=rows)

    In [14]:

    help(np.eye)
    

     

    Help on function eye in module numpy.lib.twodim_base:
    
    eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
        Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
        Parameters
        ----------
        N : int
          Number of rows in the output.
        M : int, optional
          Number of columns in the output. If None, defaults to `N`.
        k : int, optional
          Index of the diagonal: 0 (the default) refers to the main diagonal,
          a positive value refers to an upper diagonal, and a negative value
          to a lower diagonal.
        dtype : data-type, optional
          Data-type of the returned array.
        order : {'C', 'F'}, optional
            Whether the output should be stored in row-major (C-style) or
            column-major (Fortran-style) order in memory.
    
            .. versionadded:: 1.14.0
    
        Returns
        -------
        I : ndarray of shape (N,M)
          An array where all elements are equal to zero, except for the `k`-th
          diagonal, whose values are equal to one.
    
        See Also
        --------
        identity : (almost) equivalent function
        diag : diagonal 2-D array from a 1-D array specified by the user.
    
        Examples
        --------
        >>> np.eye(2, dtype=int)
        array([[1, 0],
               [0, 1]])
        >>> np.eye(3, k=1)
        array([[ 0.,  1.,  0.],
               [ 0.,  0.,  1.],
               [ 0.,  0.,  0.]])
    

    In [15]:

    # 定义一个2行的单位矩阵(列默认和行一致)
    np.eye(2)
    

    Out[15]:

    array([[1., 0.],
           [0., 1.]])
    

    In [16]:

    np.eye(3,dtype=int)
    

    Out[16]:

    array([[1, 0, 0],
           [0, 1, 0],
           [0, 0, 1]])
    

    In [17]:

    # 定义一个5行5列的单位矩阵
    np.eye(5)
    

    Out[17]:

    array([[1., 0., 0., 0., 0.],
           [0., 1., 0., 0., 0.],
           [0., 0., 1., 0., 0.],
           [0., 0., 0., 1., 0.],
           [0., 0., 0., 0., 1.]])
    

    2.2.3.矩阵乘法¶

    矩阵乘法依然要用LaTex示范一下的,不然有个别朋友恐怕依然以为相比较空虚:(大家有哪些好用的LaTex在线编辑器能够引入的卡塔 尔(英语:State of Qatar)

    拿地方十三分方程组来演示一下:

    $begin{bmatrix}1&1\2&-1\3&5end{bmatrix}begin{bmatrix}x_1\x_2end{bmatrix} ==> begin{cases}x_1 x_2\2x_1-x_2\3x_1 5x_2end{cases}$

    有一点扭转一下就更形象了:

    $begin{bmatrix}1&1\2&-1\3&5end{bmatrix}begin{bmatrix}x_1&y_1\x_2&y_2end{bmatrix} ==> begin{cases}x_1 x_2\2x_1-x_2\3x_1 5x_2end{cases} begin{cases}y_1 y_2\2y_1-x_2\3y_1 5y_2end{cases}==>begin{bmatrix}x_1 x_2&y_1 y_2\2x_1-x_2&2y_1-y_2\3x_1 5x_2&3y_1 5y_2end{bmatrix}$

    举个简单的例子:A×B

    $begin{bmatrix} 1&2 \3&4 end{bmatrix}begin{bmatrix} 4&3 \2&1 end{bmatrix}=begin{bmatrix} 1*4 2*2&1*3 2*1 \3*4 4*2&3*3 4*1 end{bmatrix}=begin{bmatrix} 8&5 \20&13 end{bmatrix}$

    从此记不得怎么乘就和好推一下,值得注意的是:

    四个矩阵的乘法仅当第叁个矩阵A的列数(column)和另三个矩阵B的行数(row)相等技术够进行总括

    您那样想就记得了:$begin{bmatrix} 1&2 \3&4 end{bmatrix}begin{bmatrix} x_1 end{bmatrix} 还原成方程组就是如此begin{cases}1*x_1 2*?\3*x_1 4*?end{cases}\那是何等鬼?至少得这么呢:begin{bmatrix} 1&2 \3&4 end{bmatrix}begin{bmatrix} x_1 \x_2 end{bmatrix}$

    In [14]:

    # 通过代码看一看
    A = np.array([[1,2],[3,4]])
    B = np.array([[4,3],[2,1]])
    
    print(A)
    print("-"*5)
    print(B)
    

     

    [[1 2]
     [3 4]]
    -----
    [[4 3]
     [2 1]]
    

    In [15]:

    # 注意一下,Numpy里面的乘法默认是每个数对应相乘
    # 如果是矩阵相乘可以使用dot()方法
    # 或者你创建矩阵对象,这样×默认就是矩阵乘法了
    
    A.dot(B) # 矩阵A×矩阵B
    

    Out[15]:

    array([[ 8,  5],
           [20, 13]])
    

     

    次第验证了大家地点的运算结果,还得小心一下:

    A×BB×A是不均等的,eg:B×A

    $begin{bmatrix} 4&3 \2&1 end{bmatrix}begin{bmatrix} 1&2 \3&4 end{bmatrix}=begin{bmatrix} 4*1 3*3&4*2 3*4 \2*1 1*3&2*2 1*4 end{bmatrix}=begin{bmatrix} 13&20 \5&8 end{bmatrix}$

    意气风发经您乘着乘着就淡忘到底怎么乘,就把侧边的矩阵换来x1,x2,然后就能够了

    In [16]:

    print(A)
    print("-"*5)
    print(B)
    

     

    [[1 2]
     [3 4]]
    -----
    [[4 3]
     [2 1]]
    

    In [17]:

    B.dot(A) # 矩阵B×矩阵A
    

    Out[17]:

    array([[13, 20],
           [ 5,  8]])
    

    In [18]:

    ################ 变化来了 ################
    

    In [19]:

    # 来验证一下”两个矩阵的乘法仅当第一个矩阵A的列数(column)和另一个矩阵D的行数(row)相等才可以进行计算“
    print(A)
    print("-"*5)
    print(D)
    

     

    [[1 2]
     [3 4]]
    -----
    [[0 1]
     [2 3]
     [4 5]]
    

    In [20]:

    # A有2列 D有3行
    A.dot(D) # 不能乘
    

     

    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-20-c1a9f22a6f8d> in <module>()
          1 # A有2列 D有3行
    ----> 2A.dot(D) # 不能乘
    
    ValueError: shapes (2,2) and (3,2) not aligned: 2 (dim 1) != 3 (dim 0)
    

    In [21]:

    # 你反过来就符合A的列数=D的行数了
    D.dot(A)
    

    Out[21]:

    array([[ 3,  4],
           [11, 16],
           [19, 28]])
    

     

    向量运算

    向量的演算很简短,其实就是逐条分类的相加减。
    以加法为例(减法相符卡塔尔国:
    ![][5]
    [5]:http://latex.codecogs.com/png.latex?begin{bmatrix}123end{bmatrix} begin{bmatrix}321end{bmatrix}=begin{bmatrix}1 32 23 1end{bmatrix}=begin{bmatrix}444end{bmatrix}

    2.6 特殊类型的矩阵和向量

    对角矩阵(diagonal matrix) 只在主对角线上带有非零成分,其余地点都以零。矩阵 $bf D$ 是对角矩阵,当且仅当 $forall i neq j, {bf D}_{i,j} = 0$ ,用 $diag(bf v)$ 表示二个对角成分由向量 $bf v$ 七月素给定的对角矩阵。

    对称(symmetric) 矩阵是专擅转置和投机相等的矩阵:
    $$
    bf A = A top
    $$
    即在矩阵 $bf A$ 中,有 ${bf A}{i,j}={bf A}{j,i}$ 。

    单位向量(unit vector卡塔尔国 是具有单位范数(unit norm卡塔 尔(阿拉伯语:قطر‎ 的向量:
    $$
    ||{bf x}||_2 = 1
    $$
    如果 ${bf x top y } = 0$ ,那么向量 $bf x$ 和向量 $bf y$ 互相正交(orthogonal)。要是多个向量都有非零范数,那么表示那七个向量之间的夹角是90 度。在$Bbb Evoque^n$ 中,至多有$n$ 个范数非零向量互相正交。要是那些向量不止相互正交,而且范数都为1,那么大家称它们是规范正交(orthonormal卡塔尔国

    正交矩阵(orthonormal matrix卡塔 尔(阿拉伯语:قطر‎ 是指行向量是标准正交的,列向量是专门的学问正交的方阵:
    $$
    bf A top A = A Atop = I
    $$
    那意味着
    $$
    bf A^{-1} = Atop
    $$
    据此正交矩阵受到关心是因为求逆总计代价小。需求当心正交矩阵的定义。反直觉地,正交矩阵的行向量不止是正交的,依旧正式正交的。对于行向量或列向量相互正交但不是明媒正礼正交的矩阵未有对应的专有术语。

    乘法

    那才是主要!!

    七个矩阵能进行乘法的前提条件是:贰个矩阵的行数等于另多个矩阵的列数

    格局化的来讲,若$A$是$i times k$的矩阵,那么$B$必须是$k times j$的矩阵!

    他俩相乘获得的$C$是$i times j$的矩阵

    其中$C_{ij} = sum_{i = 1}^n A_{ik} * B_{kj}$

    比如

    $$
    begin{bmatrix} 1 & 2\ 2 & 3 end{bmatrix}
    times

    2.2.4.幂乘、幂运算¶

    幂乘比较容易,便是各类元素开平方,不明确是方阵

    总得是方阵技能张开幂运算,比如A²=A×A(矩阵相乘前提:第一个矩阵A的行=第二个矩阵A的列==>方阵

    In [22]:

    print(A)
    print("-"*5)
    print(C)
    

     

    [[1 2]
     [3 4]]
    -----
    [[0 1 2]
     [3 4 5]]
    

    In [23]:

    # 幂乘(每个元素开平方) 
    np.power(A,2) # 使用 A**2也一样
    

    Out[23]:

    array([[ 1,  4],
           [ 9, 16]])
    

    In [24]:

    # 幂乘(不一定是方阵) 
    np.power(C,2)
    

    Out[24]:

    array([[ 0,  1,  4],
           [ 9, 16, 25]])
    

    In [25]:

    ################ 方阵幂运算 ################
    

    In [26]:

    # A*A*A
    np.linalg.matrix_power(A,3)
    

    Out[26]:

    array([[ 37,  54],
           [ 81, 118]])
    

    In [27]:

    # 不是方阵就over
    np.linalg.matrix_power(C,3)
    

     

    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-27-73f04ef7b54c> in <module>()
          1 # 不是方阵就over
    ----> 2np.linalg.matrix_power(C,3)
    
    ~/anaconda3/lib/python3.6/site-packages/numpy/matrixlib/defmatrix.py in matrix_power(M, n)
        137     M = asanyarray(M)
        138     if M.ndim != 2 or M.shape[0] != M.shape[1]:
    --> 139raise ValueError("input must be a square array")
        140     if not issubdtype(type(n), N.integer):
        141         raise TypeError("exponent must be an integer")
    
    ValueError: input must be a square array
    

     

    来个小结 扩张

    矩阵的加法运算满足沟通律:A B = B A

    矩阵的乘法知足结合律和对矩阵加法的分配律:

    结合律:(AB)C = A(BC)

    左分配律:(A B)C = AC BC

    右分配律:C(A B) = CA CB

    矩阵的乘法与数乘运算之间也满意肖似结合律的规律;与转置之间则满意倒置的

    分配律:c(A B) = cA cB

    结合律:c(AB) = (cA)B = A(cB)

    矩阵乘法不满意交流律 平日的话,矩阵A及B的乘积AB存在,但BA不肯定期存款在,即便存在,大好多时候AB ≠ BA


    向量运算几何意义:

    a b:a的源点到b的尖峰的向量;
    c-d:d的终极到c的终极的向量;

    新葡亰496net 5

    向量加减 (图截自《3D数学底工:图形与游戏支付》卡塔尔国

    2.7 特征分解

    begin{bmatrix} 2 & 4 & 5 \ 3 & 4 & 3 end{bmatrix}

    begin{bmatrix} 8 & 12 & 11 \ 13 & 20 & 19 end{bmatrix}
    $$

    新葡亰496net 6

    乘法满意结合律,左分配律,右分配律,即

    $(A times B) times C = A times (B times C)$

    $ times C = A times C B times C$

    $C = C times A C times B$

    纯属注意!矩阵乘法不满意沟通律!(超多情景下沟通之后都无法相乘)

    2.3.不一样平常矩阵¶

    向量点乘

    点乘方式:
    ![][6]
    [6]:http://latex.codecogs.com/png.latex?begin{bmatrix}a_1a_2a_3end{bmatrix}.begin{bmatrix}b_1b_2b_3end{bmatrix}=a_1b_1 a_2b_2 a_3b_3
    几何点乘公式:
    ![][7]
    [7]:http://latex.codecogs.com/png.latex?acdot{b}=left|aright|*left|bright|astcostheta
    其几何意义为向量a在向量b上的影子(当夹角超越90°时结果为负值卡塔尔

    新葡亰496net 7

    点乘 (图截自《3D数学底工:图形与游乐支付》卡塔尔

    向量点乘结果为八个标量。

    未完待续...

    矩阵飞速幂

    因为矩阵有结合律,由此大家得以把整数的赶快幂推广的矩阵上面

    难题链接

    相疑似接受二进制倍增的合计,简单获得以下代码

    里头的base,代表的是单位矩阵,也正是除了对角线全为$1$,其余岗位都为$0$的矩阵,能够表明自由矩阵乘单位矩阵都十三分小编

    显明矩阵神速幂的复杂度为$O(n^3 log k)$

    #include<cstdio>#define LL long long using namespace std;const int mod = 1e9   7;int N;LL K;struct Matrix {    int m[101][101];    Matrix operator * (const Matrix &rhs) const {        Matrix ans = {};        for(int k = 1; k <= N; k  )             for(int i = 1; i <= N; i  )                 for(int j = 1; j <= N; j  )                     (ans.m[i][j]  = 1ll * m[i][k] * rhs.m[k][j] % mod) %= mod;        return ans;    }};Matrix fastpow(Matrix a, LL p) {    Matrix base;    for(int i = 1; i <= N; i  ) base.m[i][i] = 1;//构造单位矩阵    while {        if(p & 1) base = base * a;        a = a * a; p >>= 1;    }    return base;}int main() {    scanf("%d %lld", &N, &K);    Matrix a;     for(int i = 1; i <= N; i  )            for(int j = 1; j <= N; j  )            scanf("%d", &a.m[i][j]);    a = fastpow;    for(int i = 1; i <= N; i  , puts(""))         for(int j = 1; j <= N; j  )            printf("%d ", a.m[i][j]);        return 0;}
    

    2.3.1.零矩阵¶

    零矩阵正是颇负的因素都以0

    $ begin{bmatrix} 0&0&0 \ 0&0&0 \ 0&0&0 end{bmatrix} $

    同样的:全1矩阵固然具有因素都以1

    $ begin{bmatrix} 1&1&1 \ 1&1&1 \ 1&1&1 end{bmatrix} $

    In [1]:

    import numpy as np
    

    In [2]:

    # 一维
    # 可以指定类型 np.zeros(5,dtype=int)
    np.zeros(5) # 完整写法:np.zeros((5,))
    

    Out[2]:

    array([0., 0., 0., 0., 0.])
    

    In [3]:

    # 二维
    np.zeros((2,5))# 建议用元组,官方文档都是元组
    

    Out[3]:

    array([[0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.]])
    

    In [4]:

    # 三维 ==> 可以这么理解,2个2*5(2行5列)的矩阵
    np.zeros((2,2,5))
    

    Out[4]:

    array([[[0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.]],
    
           [[0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.]]])
    

    In [5]:

    ################ 全1矩阵 ################
    

    In [6]:

    # `np.ones(tuple)` 用法和`np.zeros(tuple)`差不多
    # 可以指定类型 np.ones(5,dtype=int)
    # 一维
    np.ones(5) # 完整写法 np.ones((5,))
    

    Out[6]:

    array([1., 1., 1., 1., 1.])
    

    In [7]:

    # 二维,传一个shape元组
    np.ones((2,5))
    

    Out[7]:

    array([[1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1.]])
    

    In [8]:

    # 三维 可以理解为两个二维数组
    np.ones((2,2,5))
    

    Out[8]:

    array([[[1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1.]],
    
           [[1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1.]]])
    

    In [9]:

    ################ 指定值矩阵 ################
    

    In [10]:

    # 创建指定值的矩阵:
    np.full((3,5),222)
    

    Out[10]:

    array([[222, 222, 222, 222, 222],
           [222, 222, 222, 222, 222],
           [222, 222, 222, 222, 222]])
    

    In [11]:

    # 创建指定值的矩阵,浮点类型
    np.full((3,5),222.0)
    

    Out[11]:

    array([[222., 222., 222., 222., 222.],
           [222., 222., 222., 222., 222.],
           [222., 222., 222., 222., 222.]])
    

     

    向量叉乘

    叉乘情势:
    (其实正是,除当前进外的其余两行组成2*2矩阵,主对角线的乘积减去副对角线的乘积卡塔 尔(阿拉伯语:قطر‎
    ![][9]
    [9]:http://latex.codecogs.com/png.latex?begin{bmatrix}x_1y_1z_1end{bmatrix}timesbegin{bmatrix}x_2y_2z_2end{bmatrix}=begin{bmatrix}y_1z_2-z_1y_2z_1x_2-x_1z_2x_1y_2-y_1x_2end{bmatrix}
    几何叉乘:
    向量叉乘结果为垂直于两向量所在平面包车型大巴向量,叉乘结果向量的动向由七个,决议于坐标系为左边手坐标系依然左侧坐标系。
    倾向分辨方法为(a x b为例卡塔 尔(阿拉伯语:قطر‎:
    左边系:通过右臂法则判定,四指由a向量收向b向量,拇指方向即为结果向量方向。
    左手系:通过右臂法规推断,四指由a向量收向b向量,拇指方向即为结果向量方向。

    新葡亰496net 8

    侧边准绳/左臂段则 (图截自《3D数学底子:图形与游乐开采》卡塔尔

    新葡亰496net 9

    叉乘 (图截自《3D数学根基:图形与游戏开拓》卡塔尔

    叉乘结果向量的轻重由以下公式给出:
    ![][8]
    [8]:http://latex.codecogs.com/png.latex?left|atimes{b}right|=left|aright|*left|bright|astsintheta

    应用

    2.3.3.转置矩阵¶

    转置矩阵 :将矩阵的队列交流得到的新矩阵(行列式不改变)

    m行×n列的矩阵行和列交流后就变成了n行×m列的矩阵,eg:3行×2列 ==> 2行×3列

    $begin{bmatrix}1&2 \3&4 \5&6end{bmatrix}^T ==> begin{bmatrix}1&3&5 \2&4&6end{bmatrix}$

    矩阵的转置满足分配律:

    $(A B)^T = A^T B^T$

    $(AB)^T = B^TA^T$

    再也提示:八个矩阵的乘法仅当第贰个矩阵A的列数(column)和另多个矩阵B的行数(row)相等才足以张开计算

    In [12]:

    A = np.arange(6).reshape((2,3))
    
    print(A)
    

     

    [[0 1 2]
     [3 4 5]]
    

    In [13]:

    # 转置矩阵(行列互换)
    A.T
    

    Out[13]:

    array([[0, 3],
           [1, 4],
           [2, 5]])
    

    In [14]:

    B = np.random.randint(10,size=(2,3))
    
    print(B)
    

     

    [[4 4 7]
     [5 3 9]]
    

    In [15]:

    ################ 验证系列 ################
    

    In [16]:

    # 验证一下(A B)^T=A^T B^T
    print(A.T   B.T)
    print("-"*5)
    print((A B).T)
    

     

    [[ 4  8]
     [ 5  7]
     [ 9 14]]
    -----
    [[ 4  8]
     [ 5  7]
     [ 9 14]]
    

    In [17]:

    # 验证一下(A B)^T=A^T B^T
    # 其实也再一次验证了,Numpy运算符默认是对每一个元素的操作
    (A B).T == A.T   B.T
    

    Out[17]:

    array([[ True,  True],
           [ True,  True],
           [ True,  True]])
    

    In [18]:

    ################ 验证系列 ################
    

    In [19]:

    # 把A变成3*2的矩阵,不够元素用0补
    # reshape:有返回值,不对原始多维数组进行修改
    # resize:无返回值,会对原始多维数组进行修改
    A.resize(3,2)
    
    print(A)
    print(B)
    

     

    [[0 1]
     [2 3]
     [4 5]]
    [[4 4 7]
     [5 3 9]]
    

    In [20]:

    # 验证(AB)^T=B^T×A^T
    print((A.dot(B)).T)
    print("-"*5)
    print((B.T).dot(A.T))
    

     

    [[ 5 23 41]
     [ 3 17 31]
     [ 9 41 73]]
    -----
    [[ 5 23 41]
     [ 3 17 31]
     [ 9 41 73]]
    

     

    矩阵

    先下个简易的概念:
    倘使说向量是标量的数组,矩阵则是向量的数组。

    在Unity中,方阵较为常用。方阵是行跟列维数相近的矩阵:
    ![][10]
    [10]:http://latex.codecogs.com/png.latex?begin{bmatrix}1&2&34&5&67&8&9end{bmatrix}
    当非对角线成分全为0,则称这种矩阵为对角矩阵:
    ![][11]
    [11]:http://latex.codecogs.com/png.latex?begin{bmatrix}1&0&0&2&0&0&3end{bmatrix}
    当对角矩阵对角线全为1,则称该矩阵为单位矩阵:
    ![][12]
    [12]:http://latex.codecogs.com/png.latex?begin{bmatrix}1&0&0&1&0&0&1end{bmatrix}

    斐波那契数列第$n$项

    矩阵快捷幂最广大的运用正是优化递推啦

    只怕从最广泛的斐波那契数列提及呢。

    众周所知,斐波那契数列的递推公式为$$f_{n} = f_{n - 1} f_{n - 2}, f_1 = 1, f_2 = 1$$

    诚如的话,这种看起来长得很萌简单,只与自个儿的函数值有关的姿态,常常都能够用矩阵快速幂来加快。

    自然,假使您想找激情,可以学一下那玩意儿

    矩阵飞速幂具体是怎么加速速投递推的呢?

    首先大家把斐波那契数列写成矩阵的情势,因为$f_n$的取值与$f_{n - 1}, f_{n - 2}$这两项有关,由此大家必要同偶尔间保留这两项的值,我们简单得到一个$2 times 1$的矩阵

    $$
    begin{bmatrix}
    f_{n} \
    f_{n - 1}
    end{bmatrix}
    $$

    现行反革命我们要开展递推,也正是得到如此三个矩阵

    $$
    begin{bmatrix}
    f_{n 1} \
    f_{n}
    end{bmatrix}
    $$

    展开

    $$
    begin{bmatrix}
    f_{n} f_{n - 1} \
    f_{n}
    end{bmatrix}
    $$

    着重一下,上边的生机勃勃项须要用到$f_{n}$和$f_{n - 1}$,上边包车型大巴后生可畏项只必要用到$f_n$

    何况整合方面包车型地铁矩阵乘法的定义,大家轻松获得一个转移矩阵

    $$
    begin{bmatrix} 1 & 1 \ 1 & 0 \ end{bmatrix}

    2.3.3.上三角矩阵和下三角矩阵¶

    上三角矩阵 :主对角线以下都是零的方阵

    $begin{bmatrix} 2&9&4&7 \ 0&7&3&3 \ 0&0&6&1 \ 0&0&0&1 end{bmatrix}$

    下三角矩阵 :主对角线以上都以零的方阵

    $begin{bmatrix} 2&0&0&0 \ 3&7&0&0 \ 5&6&7&0 \ 1&2&3&4 end{bmatrix}$

    品质(行列式前边会说卡塔 尔(英语:State of Qatar)

    1. 上(下卡塔尔三角矩阵的行列式为对角线成分相乘
    2. 上(下卡塔 尔(英语:State of Qatar)三角矩阵乘以周到后也是上(下卡塔尔三角矩阵
    3. 上(下卡塔尔三角矩阵间的加减法和乘法运算的结果仍为上(下卡塔 尔(英语:State of Qatar)三角矩阵
    4. 上(下卡塔 尔(阿拉伯语:قطر‎三角矩阵的逆矩阵也照样是上(下卡塔 尔(阿拉伯语:قطر‎三角矩阵

    In [21]:

    # 创建一个5行4列矩阵
    A = np.random.randint(10,size=(4,4))
    
    print(A)
    

     

    [[3 5 2 3]
     [7 2 9 6]
     [5 1 7 6]
     [1 2 8 4]]
    

    In [22]:

    # 上三角
    np.triu(A)
    

    Out[22]:

    array([[3, 5, 2, 3],
           [0, 2, 9, 6],
           [0, 0, 7, 6],
           [0, 0, 0, 4]])
    

    In [23]:

    # 下三角
    np.tril(A)
    

    Out[23]:

    array([[3, 0, 0, 0],
           [7, 2, 0, 0],
           [5, 1, 7, 0],
           [1, 2, 8, 4]])
    

    In [24]:

    # 验证一下最后一个性质
    # 三角矩阵的逆矩阵也仍然是三角矩阵
    print(np.triu(A).T)
    print('-'*5)
    print(np.tril(A).T)
    

     

    [[3 0 0 0]
     [5 2 0 0]
     [2 9 7 0]
     [3 6 6 4]]
    -----
    [[3 7 5 1]
     [0 2 1 2]
     [0 0 7 8]
     [0 0 0 4]]
    

     

    矩阵乘法

    为平价起见,以二维矩阵为例子:
    ![][15]
    [15]:http://latex.codecogs.com/png.latex?begin{bmatrix}a_{11}&a_{12}a_{21}&a_{22}end{bmatrix}begin{bmatrix}b_{11}&b_{12}b_{21}&b_{22}end{bmatrix}=begin{bmatrix}a_{11}b_{11} a_{12}b_{21}&a_{11}b_{12} a_{12}b_{22}a_{21}b_{11} a_{22}b_{21}&a_{21}b_{12} a_{22}b_{22}end{bmatrix}

    begin{bmatrix} f_{n} \ f_{n - 1}\ end{bmatrix}

    begin{bmatrix} f_{n} f_{n - 1} \ f_{n}\ end{bmatrix}
    $$

    这么大家乘三遍就可以递推到下风流浪漫项。

    不过那样看似并从未什么样卵用啊,复杂度上还多了个矩阵相乘

    嘿嘿

    绝不忘记了,我们前面能够讲过矩阵有结合律的!

    那样的话大家只供给把调换矩阵自乘$n - 1$次,然后再与初阶矩阵相乘,就能够博得答案矩阵啦!

    难点链接

    新葡亰496net 10新葡亰496net 11

    // luogu-judger-enable-o2#include<cstdio>#include<cstring>#define LL long long using namespace std;const int mod = 1e9   7;LL K;struct Matrix {    int m[101][101], N;    Matrix() {        memset(m, 0, sizeof;        N = 2;    }    Matrix operator * (const Matrix &rhs) const {        Matrix ans;        for(int k = 1; k <= N; k  )             for(int i = 1; i <= N; i  )                 for(int j = 1; j <= N; j  )                     (ans.m[i][j]  = 1ll * m[i][k] * rhs.m[k][j] % mod) %= mod;        return ans;    }};Matrix fastpow(Matrix a, LL p) {    Matrix base;     for(int i = 1; i <= base.N; i  ) base.m[i][i] = 1;//鏋勯€犲崟浣嶇煩闃?    while {        if(p & 1) base = base * a;        a = a * a; p >>= 1;    }    return base;}int main() {    scanf("%lld", &K);    Matrix a;    a.m[1][1] = 1; a.m[1][2] = 1;    a.m[2][1] = 1; a.m[2][2] = 0;    a = fastpow(a, K - 1);    printf("%d", a.m[1][1]);    return 0;}
    

    代码

    2.3.4.对角矩阵¶

    对角矩阵 :主对角线之外的成分皆为0的方阵 (单位矩阵归于对角矩阵中的风流倜傥种卡塔 尔(阿拉伯语:قطر‎

    $begin{bmatrix}0&0&0 \0&0&0 \0&0&0end{bmatrix} begin{bmatrix}1&0&0 \0&1&0 \0&0&1end{bmatrix} begin{bmatrix}2&0&0 \0&2&0 \0&0&2end{bmatrix} begin{bmatrix}3&0&0 \0&9&0 \0&0&6end{bmatrix}$

    举一反三:对角矩阵的运算满含和、差运算、数乘运算、同阶对角阵的乘积运算,且结果仍然是对角阵

    再者有趣的是:对角矩阵的矩阵幂运算等于其对应成分的幂运算

    $begin{bmatrix}3&0&0 \0&9&0 \0&0&6end{bmatrix}^n = begin{bmatrix}3^n&0&0 \0&9^n&0 \0&0&6^nend{bmatrix}$

    In [25]:

    # 简单创建
    np.diag([3,9,6])
    

    Out[25]:

    array([[3, 0, 0],
           [0, 9, 0],
           [0, 0, 6]])
    

    In [26]:

    np.diag([2,2,2])
    

    Out[26]:

    array([[2, 0, 0],
           [0, 2, 0],
           [0, 0, 2]])
    

    In [27]:

    ################ 验证系列 ################
    

    In [28]:

    # np.diag?
    print(A)
    
    # 获取对角元素,然后再生成对角矩阵
    B = np.diag(A.diagonal()) #或者 np.diag(np.diag(A))
    
    print(B)
    

     

    [[3 5 2 3]
     [7 2 9 6]
     [5 1 7 6]
     [1 2 8 4]]
    [[3 0 0 0]
     [0 2 0 0]
     [0 0 7 0]
     [0 0 0 4]]
    

    In [29]:

    B.dot(B).dot(B)
    

    Out[29]:

    array([[ 27,   0,   0,   0],
           [  0,   8,   0,   0],
           [  0,   0, 343,   0],
           [  0,   0,   0,  64]])
    

    In [30]:

    # 对角矩阵的矩阵幂运算等于其对应元素的幂运算
    B**3
    

    Out[30]:

    array([[ 27,   0,   0,   0],
           [  0,   8,   0,   0],
           [  0,   0, 343,   0],
           [  0,   0,   0,  64]])
    

     

    向量与矩阵的乘法

    ![][16]
    [16]:http://latex.codecogs.com/png.latex?begin{bmatrix}x&y&zend{bmatrix}begin{bmatrix}m_{11}&m_{12}&m_{13}m_{21}&m_{22}&m_{23}m_{31}&m_{32}&m_{33}end{bmatrix}=begin{bmatrix}xm_{11} ym_{21} zm_{31}&xm_{12} ym_{22} zm_{32}&xm_{13} ym_{23} zm_{33}end{bmatrix}
    ![][17]
    [17]:http://latex.codecogs.com/png.latex?begin{bmatrix}m_{11}&m_{12}&m_{13}m_{21}&m_{22}&m_{23}m_{31}&m_{32}&m_{33}end{bmatrix}begin{bmatrix}xyzend{bmatrix}=begin{bmatrix}xm_{11} ym_{12} zm_{13}xm_{21} ym_{22} zm_{23}xm_{31} ym_{32} zm_{33}end{bmatrix}
    由上可以看见,行向量左乘矩阵,结果是行向量;列向量右乘矩阵,结果是列向量。
    (Ps:在Unity中,常把向量方在矩阵的左侧,即选择列向量举办演算。此种情形下,大家阅读的各种应该为从右往左阅读,即:中职篮v为对向量v先进行A矩阵转换,再实行B,最终进行C矩阵转换。矩阵调换请以往看卡塔 尔(阿拉伯语:قطر‎

    门路计数难题

    付出四个 n * n 的分界矩阵A.A是四个01矩阵 .A[i][j]=1代表i号点和j号点之间有长度为1的边从来相连.求出从 1 号点 到 n 号点长度为k的路径的数目.

    做法:直接对交付的矩阵火速幂$k$次,输出$A[1][N]$

    释疑:思谋矩阵相乘的进度,大家对此要总结的$$地点,大家一定于是枚举了叁当中级节点$k$,来总括$ * $

    2.3.5.单位矩阵¶

    单位矩阵 :单位矩阵是个方阵(行列相等卡塔尔,从左上角到右下角的对角线(称为主对角线卡塔尔国上的因素均为1。其余全都为0,eg:

    $ begin{bmatrix} 1&0&0 \ 0&1&0 \ 0&0&1 end{bmatrix} $

    任何矩阵 x 单位矩阵 都等于其本身 (反过来也后生可畏致(那个和1×a=a×1一个道理卡塔尔卡塔 尔(英语:State of Qatar)

    In [31]:

    # 定义一个2行的单位矩阵(列默认和行一致)
    # np.eye(rows,columns=rows)
    np.eye(2)
    

    Out[31]:

    array([[1., 0.],
           [0., 1.]])
    

    In [32]:

    ################ 验证扩展 ################
    

    In [33]:

    # 可以指定类型
    B = np.eye(4,dtype=int)
    
    print(B)
    

     

    [[1 0 0 0]
     [0 1 0 0]
     [0 0 1 0]
     [0 0 0 1]]
    

    In [34]:

    print(A)
    

     

    [[3 5 2 3]
     [7 2 9 6]
     [5 1 7 6]
     [1 2 8 4]]
    

    In [35]:

    # 任何矩阵 x 单位矩阵 都等于其本身
    A.dot(B)
    

    Out[35]:

    array([[3, 5, 2, 3],
           [7, 2, 9, 6],
           [5, 1, 7, 6],
           [1, 2, 8, 4]])
    

    In [36]:

    # 反过来也一样(这个和1*a=a*1一个道理)
    B.dot(A)
    

    Out[36]:

    array([[3, 5, 2, 3],
           [7, 2, 9, 6],
           [5, 1, 7, 6],
           [1, 2, 8, 4]])
    

     

    矩阵的几何意义

    矩阵常用与坐标系的转移。
    先交给明白:矩阵中的每后生可畏行都能疏解为转移后的基向量(基向量:坐标轴向量,在三个维度空间中维X,Y,Z轴,当长度为1时称为标准基向量卡塔 尔(英语:State of Qatar)。
    先用2维坐标为例:
    对转移矩阵:
    ![][18]
    [18]:http://latex.codecogs.com/png.latex?M=begin{bmatrix}2&1-1&2end{bmatrix}

    新葡亰496net 12

    坐标轴转变 (图截自《3D数学底工:图形与娱乐支付》卡塔尔

    如上图所示:x轴从品位单位长度调换成点p(2,1),y轴从垂直单位长度转变来点q(-1,2);也正是说,该矩阵所达成的效率是让坐标系旋转角度并比例放大,换个说法,坐标轴从原先的坐标系转变成了新的坐标系了。

    新葡亰496net 13

    转移职能 (图截自《3D数学底子:图形与娱乐开拓》卡塔尔

    上海教室可以观察转变职能:旋转并放大

    上边看看3维坐标的机能:
    3D转变矩阵:
    ![][19]
    [19]:http://latex.codecogs.com/png.latex?begin{bmatrix}0.707&-0.707&01.250&1.250&0&0&1end{bmatrix}

    新葡亰496net 14

    原效果 (图截自《3D数学根基:图形与游乐开拓》卡塔 尔(英语:State of Qatar)

    新葡亰496net 15

    转移后 (图截自《3D数学底工:图形与娱乐支付》卡塔 尔(阿拉伯语:قطر‎

    能够看见,调换矩阵中每生龙活虎行对应转换X,Y,Z轴,该调换矩阵的意义为沿Z轴旋转45°,并张开不法规缩放。

    别的的不足为道矩阵推导

    $$G_i = atimes G_{i - 1} btimes G_{i - 2}$$

    begin{equation*}
    begin{bmatrix}
    a&b\
    1 & 0\
    end{bmatrix}^{i - 1}times
    begin{bmatrix}
    G_{1}\
    G_{0}\
    end{bmatrix}=
    begin{bmatrix}
    a&b\
    1 & 0\
    新葡亰496net:矩阵快捷幂小结,机器学习中的线性代数知识。end{bmatrix}times
    begin{bmatrix}
    G_{i - 1}\
    G_{i - 2}\
    end{bmatrix}=
    begin{bmatrix}
    G_{i}\
    G_{i - 1}\
    end{bmatrix}
    end{equation*}

    $$G_i = atimes G_{i - 1} i^2$$

    begin{equation*}
    begin{bmatrix}
    a&1&0&0\
    0 & 1&2&1\
    0 & 0&1&1\
    0 & 0&0&1\
    end{bmatrix}^{i}times
    begin{bmatrix}
    G_{0}\
    1\
    1\
    1\
    end{bmatrix}=
    begin{bmatrix}
    a&1&0&0\
    0 & 1&2&1\
    0 & 0&1&1\
    0 & 0&0&1\
    end{bmatrix}times
    begin{bmatrix}
    G_{i - 1}\
    i^2\
    i\
    1
    end{bmatrix}=
    begin{bmatrix}
    G_{i}\
    ^2\
    i 1\
    1
    end{bmatrix}
    end{equation*}

    $$G_i = atimes G_{i - 1} i^3$$

    begin{equation*}
    begin{bmatrix}
    a&1&0&0&0\
    0 & 1&3&3&1\
    0 & 0&1&2&1\
    0 & 0&0&1&1\
    0 & 0&0&0&1\
    end{bmatrix}^{i}*
    begin{bmatrix}
    G_{0}\
    1\
    1\
    1\
    1\
    end{bmatrix}=
    begin{bmatrix}
    a&1&0&0&0\
    0 & 1&3&3&1\
    0 & 0&1&2&1\
    0 & 0&0&1&1\
    0 & 0&0&0&1\
    end{bmatrix}times
    begin{bmatrix}
    G_{i - 1}\
    i^3\
    i^2\
    i\
    1
    end{bmatrix}=
    begin{bmatrix}
    G_{i}\
    ^3\
    ^2\
    i 1\
    1
    end{bmatrix}
    end{equation*}

    $$G_i = atimes G_{i - 1} b^i$$

    begin{equation*}
    begin{bmatrix}
    a&1\
    0 & b\
    end{bmatrix}^{i}times
    begin{bmatrix}
    G_{0}\
    b\
    end{bmatrix}=
    begin{bmatrix}
    a&1\
    0 & b\
    end{bmatrix}times
    begin{bmatrix}
    G_{i - 1}\
    b^{i}\
    end{bmatrix}=
    begin{bmatrix}
    G_{i}\
    b^{i 1}\
    end{bmatrix}
    end{equation*}

    2.3.6.对称矩阵¶

    对称矩阵 :成分以主对角线为对称轴对应极其的方阵

    对称矩阵的转置是它本人:$A^T=A$

    In [37]:

    A = np.random.randint(10,size=(4,4))
    
    print(A)
    

     

    [[0 1 6 9]
     [1 2 4 7]
     [4 8 7 9]
     [3 6 8 0]]
    

    In [38]:

    B = np.triu(A)
    B  = B.T - np.diag(A.diagonal())
    print(B)
    

     

    [[0 1 6 9]
     [1 2 4 7]
     [6 4 7 9]
     [9 7 9 0]]
    

    In [39]:

    # 验证一下
    B.T == B
    

    Out[39]:

    array([[ True,  True,  True,  True],
           [ True,  True,  True,  True],
           [ True,  True,  True,  True],
           [ True,  True,  True,  True]])
    

    In [40]:

    ################ 分步解释 ################
    

    In [41]:

    # 创建上三角矩阵
    B = np.triu(A)
    
    print(B)
    

     

    [[0 1 6 9]
     [0 2 4 7]
     [0 0 7 9]
     [0 0 0 0]]
    

    In [42]:

    # 上三角 它的逆矩阵(发现距离对角矩阵只是多加一次对角线上的元素)
    B  = B.T
    
    print(B)
    

     

    [[ 0  1  6  9]
     [ 1  4  4  7]
     [ 6  4 14  9]
     [ 9  7  9  0]]
    

    In [43]:

    # 所以减去对角线上的元素,得到对角矩阵
    B - np.diag(A.diagonal())
    

    Out[43]:

    array([[0, 1, 6, 9],
           [1, 2, 4, 7],
           [6, 4, 7, 9],
           [9, 7, 9, 0]])
    

     

    大家得以得出结论:
    • 方阵的行能被批注为坐标系的基向量
    • 向量乘以贰个矩阵,将从原坐标系转换来新坐标系
    • 从原坐标系到这个基向量定义的新坐标系的转移是意气风发种线性别变化换。线性别变化换保持直线和平行线,但角度、长度、面积或体积或者会被转移。

    参谋资料

    《深入显出矩阵飞快幂及其简单利用》

    2.4.逆矩阵¶

    逆矩阵 :设A是数域上的八个n阶方阵,若在肖似数域上存在另一个n阶矩阵B,使得:AB=BA=E 则大家称B是A的逆矩阵(表示为$A^{-1}$),而A则被称呼可逆矩阵

    深入显出话讲便是:原矩阵×逆矩阵=逆矩阵×原矩阵=单位矩阵

    转置矩阵

    转置矩阵即为沿对角线翻转的矩阵:
    ![][13]
    [13]:http://latex.codecogs.com/png.latex?{begin{bmatrix}1&2&34&5&67&8&9end{bmatrix}}^T=begin{bmatrix}1&4&72&5&83&6&9end{bmatrix}
    对此向量,行向量变为列向量为:
    ![][14]
    [14]:http://latex.codecogs.com/png.latex?{begin{bmatrix}1&2&3end{bmatrix}}^T=begin{bmatrix}123end{bmatrix}
    转置矩阵的性质:
    ![][21]
    [21]:http://latex.codecogs.com/png.latex?(MT)T=M,(AB)T=BTA^T

    2.4.1.消元法¶

    或是朝气蓬勃见到逆矩阵,我们就悟出代数余子式 ,然则逆天要说的是,代数余子式就和我们技术员面试题肖似,有个别难题便是又麻烦实际利用又没多大体思的主题材料同样,超级多时候面试官都不看面试题一眼,雷同的那个出题老师自身解题平常都不会接纳。作者那边介绍一下方便轻便的不二法门“消元法

    比如求$begin{bmatrix}3&2 \1&2end{bmatrix}^{-1}$,就能够表示为:

    $begin{bmatrix}3&2 \1&2end{bmatrix}begin{bmatrix}x_{11}&x_{12} \x_{21}&x_{22}end{bmatrix}=begin{bmatrix}1&0 \0&1end{bmatrix}$

    更换到方程组:

    $begin{cases} begin{bmatrix}3&2 \1&2end{bmatrix}begin{bmatrix}x_{11} \x_{21}end{bmatrix}=begin{bmatrix}1 \0end{bmatrix}\ begin{bmatrix}3&2 \1&2end{bmatrix}begin{bmatrix}x_{12} \x_{22}end{bmatrix}=begin{bmatrix}0 \1end{bmatrix} end{cases} ==> 求方程组begin{cases}3x_{11} 2x_{21}=1\1x_{11} 2x_{21}=0end{cases}和begin{cases}3x_{12} 2x_{22}=0\1x_{12} 2x_{22}=1end{cases}的解$

    这么很自在就可以解出逆矩阵了

    $begin{cases}x_{11}=frac{1}{2}\x_{21}=-frac{1}{4} end{cases}\begin{cases}x_{12}=-frac{1}{2}\x_{22}=frac{3}{4} end{cases}\ ==> begin{bmatrix}frac{1}{2}&-frac{1}{2} \-frac{1}{4}&frac{3}{4} end{bmatrix}$

    In [44]:

    A = np.array([[3,2],[1,2]])
    
    print(A)
    

     

    [[3 2]
     [1 2]]
    

    In [45]:

    # 求A的逆矩阵
    np.linalg.inv(A)
    

    Out[45]:

    array([[ 0.5 , -0.5 ],
           [-0.25,  0.75]])
    

     

    逆矩阵

    不是各类矩阵都会有逆矩阵,首先的前提条件是,该矩阵是方阵。
    逆矩阵的性质:矩阵M和其逆矩阵相乘,其结果是单位矩阵。
    ![][20]
    [20]:http://latex.codecogs.com/png.latex?MM{-1}=M{-1}M=I
    风流罗曼蒂克经叁个矩阵有逆矩阵,那大家就说这几个矩阵是可逆的。轻巧判别一个矩阵是还是不是可逆的点子是,求那些矩阵的行列式,假使结果不为0,则那么些矩阵是可逆的。(行列式的求解以至怎么求取逆矩阵,进程相对相比较复杂,大家能够查阅别的资料卡塔 尔(英语:State of Qatar)

    逆矩阵的性质:
    ![][22]
    [22]:http://latex.codecogs.com/png.latex?(M{-1}){-1}=M,(MT){-1}=(M{-1})T,(AB){-1}=B{-1}A^{-1}
    在三个维度调换中,大家平常需求通过逆矩阵来求解反向的转移

    2.4.2.二阶方阵公式¶

    若果只是2阶方阵,有更简短的公式(只可以2阶使用,而消元法不受限定卡塔 尔(阿拉伯语:قطر‎矩阵是不是可逆就看分母是或不是为0

    $large{begin{bmatrix}a_{11}&a_{12} \a_{21}&a_{22}end{bmatrix}=frac{1}{a_{11}a_{22}-a_{12}a_{21}}begin{bmatrix}a_{22}&-a_{12} \-a_{21}&a_{11}end{bmatrix}}$

    比如求$begin{bmatrix}3&2 \1&2end{bmatrix}^{-1}$:

    新葡亰496net:矩阵快捷幂小结,机器学习中的线性代数知识。$frac{1}{3×2-2×1}begin{bmatrix}2&-2 \-1&3end{bmatrix}=begin{bmatrix}frac{1}{2}&-frac{1}{2} \-frac{1}{4}&frac{3}{4} end{bmatrix}$

    正交矩阵

    正交矩阵是其与其转置矩阵的乘积是单位矩阵的矩阵,即:
    ![][23]
    [23]:http://latex.codecogs.com/png.latex?MMT=MTM=I
    大家能够对照逆矩阵的性质
    ![][24]
    [24]:http://latex.codecogs.com/png.latex?MM{-1}=M{-1}M=I
    咱俩得以吸收二个很有用的新闻:
    假如三个矩阵是正交矩阵,大家能够通过求转置的章程求出其逆矩阵,那将得以大大超少运算量
    正如名字如出风流洒脱辙,这种矩阵的3个基向量分别是正交关系,即相互垂直,由于
    ![][25]
    [25]:http://latex.codecogs.com/png.latex?MM^T=begin{bmatrix}-&c_1&--&c_2&--&c_3&-end{bmatrix}begin{bmatrix}|&|&|c_1&c_2&c_3|&|&|end{bmatrix}=begin{bmatrix}c_1c_1&c_1c_2&c_1c_3c_2c_1&c_2c_2&c_2c_3c_3c_1&c_3c_2&c_3c_3end{bmatrix}=begin{bmatrix}1&0&0&1&0&0&1end{bmatrix}
    能够观望矩阵的每风姿罗曼蒂克行c1,c2,c3亟须为单位矢量,唯有这样点乘的结果技术是1。
    也正是说,大家有很简短的方式来驾驭多个矩阵是不是为正交矩阵,即
    c1,c2,c3均为单位矢量而且相互垂直


    边忙边写写了数天,终于写好了。。。数学真是意气风发门神奇的学科。

    扩大体系:伪逆矩阵¶

    非方阵能够求 伪逆矩阵 AXA=A,XAX=X

    推断矩阵是不是可逆:

    $$detbegin{bmatrix}a_{11}&a_{12} \a_{21}&a_{22}end{bmatrix}=a_{11}a_{12}-a_{12}a_{21}\detbegin{bmatrix}a_{11}&a_{12}&a_{13} \a_{21}&a_{22}&a_{23}\a_{31}&a_{32}&a_{33}end{bmatrix}=a_{11}a_{22}a_{33} a_{12}a_{23}a_{31} a_{13}a_{21}a_{32}-a_{13}a_{22}a_{31}-a_{12}a_{21}a_{33}-a_{11}a_{23}a_{32}$$

    措施非常多(比方还足以通过余子式),公式其实有规律,你能够先找找下(给个提醒):

    正负
    a11a22
    a12a21 -
    正负
    a11a22a33
    a11a23a32 -
    a12a21a33 -
    a12a23a31
    a13a21a32
    a13a22a31 -

    先后比较轻易:np.linalg.det(A)

    In [46]:

    A = np.array([[7, 3, 6],[5, 3, 1]])
    
    print(A)
    

     

    [[7 3 6]
     [5 3 1]]
    

    In [47]:

    # 不等于0就是可逆
    np.linalg.det(A)
    

     

    ---------------------------------------------------------------------------
    LinAlgError                               Traceback (most recent call last)
    <ipython-input-47-2ce8e7bdf499> in <module>()
          1 # 不等于0就是可逆
    ----> 2np.linalg.det(A)
    
    ~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in det(a)
       1869     a = asarray(a)
       1870     _assertRankAtLeast2(a)
    -> 1871_assertNdSquareness(a)
       1872     t, result_t = _commonType(a)
       1873     signature = 'D->D' if isComplexType(t) else 'd->d'
    
    ~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in _assertNdSquareness(*arrays)
        209     for a in arrays:
        210         if max(a.shape[-2:]) != min(a.shape[-2:]):
    --> 211raise LinAlgError('Last 2 dimensions of the array must be square')
        212 
        213 def _assertFinite(*arrays):
    
    LinAlgError: Last 2 dimensions of the array must be square
    

    In [48]:

    # 必须是方阵的验证
    np.linalg.inv(A)
    

     

    ---------------------------------------------------------------------------
    LinAlgError                               Traceback (most recent call last)
    <ipython-input-48-0af3c81a492f> in <module>()
          1 # 必须是方阵的验证
    ----> 2np.linalg.inv(A)
    
    ~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in inv(a)
        521     a, wrap = _makearray(a)
        522     _assertRankAtLeast2(a)
    --> 523_assertNdSquareness(a)
        524     t, result_t = _commonType(a)
        525 
    
    ~/anaconda3/lib/python3.6/site-packages/numpy/linalg/linalg.py in _assertNdSquareness(*arrays)
        209     for a in arrays:
        210         if max(a.shape[-2:]) != min(a.shape[-2:]):
    --> 211raise LinAlgError('Last 2 dimensions of the array must be square')
        212 
        213 def _assertFinite(*arrays):
    
    LinAlgError: Last 2 dimensions of the array must be square
    

    In [49]:

    # 有时候还是需要求逆矩阵
    # 那就可以求它的伪逆矩阵
    X = np.linalg.pinv(A)
    
    print(X)
    

     

    [[-0.00632911  0.15189873]
     [-0.05696203  0.16708861]
     [ 0.20253165 -0.26075949]]
    

    In [50]:

    # A*X*A=A
    A.dot(X).dot(A)
    

    Out[50]:

    array([[7., 3., 6.],
           [5., 3., 1.]])
    

    In [51]:

    # X*A*X=X
    X.dot(A).dot(X)
    

    Out[51]:

    array([[-0.00632911,  0.15189873],
           [-0.05696203,  0.16708861],
           [ 0.20253165, -0.26075949]])
    

    In [52]:

    ################ 简单说下mat ################
    

    In [53]:

    # 创建一个矩阵
    A = np.mat([[3,2],[1,2]])
    
    print(A)
    type(A)
    

     

    [[3 2]
     [1 2]]
    

    Out[53]:

    numpy.matrixlib.defmatrix.matrix
    

    In [54]:

    # 求它的逆矩阵
    A.I
    

    Out[54]:

    matrix([[ 0.5 , -0.5 ],
            [-0.25,  0.75]])
    

    In [55]:

    # A^T
    A.T
    

    Out[55]:

    matrix([[3, 1],
            [2, 2]])
    

    In [56]:

    # *默认就是矩阵乘法
    A * A
    

    Out[56]:

    matrix([[11, 10],
            [ 5,  6]])
    

    In [57]:

    # 更多自己查看下帮助文档把,用法和array基本上一样,
    # 我这边只是简单提一下,怕你们不去看(所有和矩阵相关的东西,里面都有封装,很方便)
    np.mat?
    

    本文由新葡亰496net发布于电脑系统,转载请注明出处:新葡亰496net:矩阵快捷幂小结,机器学习中的线

    关键词:

上一篇:模块专栏,模块总结

下一篇:没有了