精华内容
下载资源
问答
  • 矩阵叉乘的意义

    千次阅读 2019-04-17 21:57:55
    矩阵叉乘:叉乘的结果是一个向量。方向垂直于原先两个向量构成的平面。 大小为:原来两个向量在平面形成的平行四边形的面积。

    矩阵叉乘:叉乘的结果是一个向量。方向垂直于原先两个向量构成的平面。
    大小为:原来两个向量在平面形成的平行四边形的面积。

    展开全文
  • 对偶性的实质就是转置,【1,2】的转置是【1  2】这从向量的角度就是维度的增加,向量之间有唯一的对应关系。这里的两个向量就是对偶的关系。也就是我们所说的转置矩阵。...向量内积就是矩阵叉乘...

    对偶性的实质就是转置,【1,2】的转置是【1

                                                                                    2】这从向量的角度就是维度的增加,向量之间有唯一的对应关系。这里的两个向量就是对偶的关系。也就是我们所说的转置矩阵。

    向量内积就是矩阵叉乘

    展开全文
  • 熟练使用python计算向量、矩阵、数组之后,是不是就不用matlab了?应该不是,matlab的函数完善,而python我还不知道缺什么函数和功能。 基本操作 创建 import numpy as np #创建行向量[1,2,3] print(np.array([1,2,...

    前言

    熟练使用python计算向量、矩阵、数组之后,是不是就不用matlab了?应该不是,matlab的函数完善,而python我还不知道缺什么函数和功能。


    基本操作

    创建

    import numpy as np
    #创建行向量[1,2,3]
    print(np.array([1,2,3]))
    
    #创建列向量[[1],[2],[3]]
    print(np.array([[1],[2],[4]]))
    
    #创建矩阵
    print(np.array([[1,2,3],[4,5,6],[7,8,9]]))
    
    #创建矩阵
    print(np.mat([[1,2,3],[4,5,6],[7,8,9]])) #不推荐,因为大多数操作都是数组而不是矩阵数据结构mat
    
    
    #-------创建三维矩阵-------
    
    #创建1个2X3的0矩阵
    print('>',np.zeros((1,2,3)))
    
    #创建两个2X2的0矩阵
    print('>',np.zeros((2,2,2)))
    
    #创建两个3X3的1矩阵
    print('>>>',np.ones((2,3,3)))
    
    
    #-----------------------
    
    
    from scipy import sparse
    #创建稀疏矩阵
    matrix =np.array([[0,0,0,1],[0,2,0,1],[1,0,3,0]])
    #创建一个压缩的稀疏行矩阵compressed sparse row
    print(sparse.csr_matrix(matrix))
    
    [1 2 3]
    [[1]
     [2]
     [4]]
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    > [[[0. 0. 0.]
      [0. 0. 0.]]]
    > [[[0. 0.]
      [0. 0.]]
    
     [[0. 0.]
      [0. 0.]]]
    >>> [[[1. 1. 1.]
      [1. 1. 1.]
      [1. 1. 1.]]
    
     [[1. 1. 1.]
      [1. 1. 1.]
      [1. 1. 1.]]]
      (0, 3)	1
      (1, 1)	2
      (1, 3)	1
      (2, 0)	1
      (2, 2)	3
    

    选择元素

    import numpy as np
    from scipy import sparse
    #创建行向量
    v = np.array([1,2,3,4,5,6])
    #创建矩阵
    m = np.array([[1,2,3],
                  [4,5,6],
                  [7,8,9]])
    
    #第5个
    print(v[5-1])
    #第三行第二个元素
    print(m[3-1][2-1])
    print(m[2,1])
    
    
    #选取向量所有元素
    print(v[:])
    
    #选取0到第三个
    print(v[:3])
    
    #选取第三个到最后
    print(v[3:])
    
    #选取最后一个
    print(v[-1])
    
    
    #选取矩阵全部
    print(m[:])
    print(m)
    
    #选取矩阵第一行
    print(m[0,:])
    
    #选取第一行和第三行
    print(m[0,:],m[2,:])
    
    #选取第二列
    print(m[:,1])
    
    5
    8
    8
    [1 2 3 4 5 6]
    [1 2 3]
    [4 5 6]
    6
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    [1 2 3]
    [1 2 3] [7 8 9]
    [2 5 8]
    

    矩阵的属性

    import numpy as np
    from scipy import sparse
    m = np.array([[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12]])
    
    #行,列
    a = m.shape
    print(a)
    print('r=%d,c=%d'%(a[0],a[1]))
    
    #元素数量
    print(m.size)
    
    #矩阵的维数
    print(m.ndim)
    
    (3, 4)
    r=3,c=4
    12
    2
    

    虽然矩阵有4列,但是因为4个基向量是线性相关的,最大线性无关组只有两个,维数也就只有两个。

    矩阵的秩

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0]])
    
    print(np.linalg.matrix_rank(m))
    
    2
    

    矩阵的迹

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0]])
    
    print(m.trace())
    
    15
    

    vectorize

    import numpy as np
    from scipy import sparse
    #创建行向量
    v = np.array([1,2,3,4,5,6])
    #创建矩阵
    m = np.array([[1,2,3],
                  [4,5,6],
                  [7,8,9]])
    
    
    
    #创建一个向量化的函数
    func = np.vectorize(lambda x:x+100)  #vectorize把一个函数变成另一个函数
    #对所有元素应用这个函数
    print(func(m))
    
    #直接操作也行
    print(m-100)
    
    print(m*2)
    
    print(m/2)
    
    
    [[101 102 103]
     [104 105 106]
     [107 108 109]]
    [[-99 -98 -97]
     [-96 -95 -94]
     [-93 -92 -91]]
    [[ 2  4  6]
     [ 8 10 12]
     [14 16 18]]
    [[0.5 1.  1.5]
     [2.  2.5 3. ]
     [3.5 4.  4.5]]
    

    最值、平均值、方差、标准差

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3],
                  [4,5,6],
                  [7,8,9]])
    
    print(np.max(m))
    print(np.min(m))
    print(np.mean(m))
    print(np.var(m))
    print(np.std(m))
    
    9
    1
    5.0
    6.666666666666667
    2.581988897471611
    

    矩阵变形

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0]])
    
    #变形前后元素个数一样
    print(m.reshape(2,6))
    
    [[1 2 3 0 4 5]
     [6 0 7 8 9 0]]
    

    转置

    import numpy as np
    from scipy import sparse
    #创建行向量
    v = np.array([1,2,3,4,5,6,7,8,9])
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0]])
    
    print(m.T)
    
    #向量只是值的集合,不能转置
    print(v)
    print(v.T)
    print(np.array([1,2,3,4,5,6,7,8,9]).T)
    
    [[1 4 7]
     [2 5 8]
     [3 6 9]
     [0 0 0]]
    [1 2 3 4 5 6 7 8 9]
    [1 2 3 4 5 6 7 8 9]
    [1 2 3 4 5 6 7 8 9]
    

    矩阵展开

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0]])
    
    print(m.flatten())
    
    [1 2 3 0 4 5 6 0 7 8 9 0]
    

    高级操作

    行列式

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0],
                  [0,0,0,0]])
    
    print(np.linalg.det(m))
    
    0.0
    

    对角线元素

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,0],
                  [4,5,6,0],
                  [7,8,9,0] ])
    
    print(m.diagonal())
    
    [1 5 9]
    

    特征值和特征向量

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,7],
                  [4,5,6,0],
                  [7,8,9,0],
                  [0,0,1,4]])
    
    #特征值和特征向量
    a,b = np.linalg.eig(m)
    
    print(a)
    print('-------------')
    print(b)
    
    [16.33839194+0.j         -0.29035096+0.55867363j -0.29035096-0.55867363j
      3.24230999+0.j        ]
    -------------
    [[-0.25665901+0.j         -0.69644039+0.j         -0.69644039-0.j
       0.70851102+0.j        ]
     [-0.52018868+0.j          0.14699415-0.42878781j  0.14699415+0.42878781j
      -0.35480461+0.j        ]
     [-0.81191118+0.j          0.37461056+0.39175996j  0.37461056-0.39175996j
      -0.36840126+0.j        ]
     [-0.06580365+0.j         -0.07416678-0.10096959j -0.07416678+0.10096959j
       0.48621634+0.j        ]]
    
    

    点积和叉积

    import numpy as np
    from scipy import sparse
    
    a = np.array([1,2,3,4])
    b = np.array([11,2,3,4])
    print(np.dot(a,b))
    
    
    c = np.array([[34,2],
                  [1,3]])
    d = np.array([[2,9],
                  [0,1]])
    print(np.cross(c,d)) #cross必须是两个二维矩阵相叉乘,或两个三维矩阵相叉乘
    
    
    e = np.array([[1,2],
                  [1,0]])
    f = np.array([[3,5],
                  [1,2]])
    print(np.cross(e,f))
    
    40
    [302   1]
    [-1  2]
    

    两个二维矩阵叉乘公式
    A = [ a 11 a 12 a 21 a 22 ] A = \left[ \begin{matrix} a_{11} \quad a_{12} \\ a_{21} \quad a_{22} \\ \end{matrix}\\ \right] A=[a11a12a21a22]
    B = [ b 11 b 12 b 21 b 22 ] B = \left[ \begin{matrix} b_{11} \quad b_{12} \\ b_{21} \quad b_{22} \\ \end{matrix} \right] B=[b11b12b21b22]

    A × B = [ a 11 b 12 − a 12 b 11 a 21 b 22 − a 22 b 21 ] A\times B = \left[ \begin{matrix} a_{11}b_{12} - a_{12}b_{11} \qquad a_{21}b_{22} - a_{22}b_{21}\end{matrix}\right] A×B=[a11b12a12b11a21b22a22b21]

    矩阵的逆

    import numpy as np
    from scipy import sparse
    #创建矩阵
    m = np.array([[1,2,3,7],
                  [4,5,6,4],
                  [7,8,9,2],
                  [1,3,12,5]])
    
    print(np.linalg.inv(m))
    
    [[ 8.42857143e+00 -2.01428571e+01  1.04285714e+01  1.42857143e-01]
     [-8.85714286e+00  2.12857143e+01 -1.08571429e+01 -2.85714286e-01]
     [ 1.09523810e+00 -2.80952381e+00  1.42857143e+00  1.42857143e-01]
     [ 1.00000000e+00 -2.00000000e+00  1.00000000e+00  1.70803542e-17]]
    

    生成随机数

    import numpy as np
    
    #设置随机数种子
    np.random.seed(0)
    
    #生成3个0到1的数
    print(np.random.random(3))  #默认0~1
    
    #生成3个1到100的整数
    print(np.random.randint(0,101,3))
    
    #从1<=x<2 中抽3个
    print(np.random.uniform(1,2,3))
    
    #正态分布
    #平均值0,标准差1
    print(np.random.normal(0,1,3))
    
    #逻辑分布
    #平均值0,散布程度1
    print(np.random.logistic(0,1,3))
    
    [0.5488135  0.71518937 0.60276338]
    [67  9 83]
    [1.64589411 1.43758721 1.891773  ]
    [-0.10321885  0.4105985   0.14404357]
    [ 0.27387744  2.52093742 -2.57088231]
    
    展开全文
  • 向量和矩阵的点乘和叉乘

    万次阅读 多人点赞 2020-05-24 11:14:55
    向量 定义:向量是由N个实数组成的一...叉乘:又叫向量积、外积、叉积,叉乘,向量a[x1,y1,z1]和向量b[x2,y2,z2]叉乘的运算结果是一个向量,并且两个向量的叉积与这两个向量组成的坐标平面垂直,记作axb; 计算方式:.

    向量


    定义:向量是由N个实数组成的一行N列或N行一列的的数组。

    • 点乘:又叫做点积、内积、数量积、标量积,向量a[a1,a2,...,an]和向量b[b1,b2b...,bn]点乘的结果是一个标量,记作a.b

    几何解释:a.b = |a| |b| cos \theta,故而点乘可以计算出两个向量的夹角,且向量垂直,点乘结果为零。

    • 叉乘:又叫向量积、外积、叉积,叉乘,向量a[x1,y1,z1]和向量b[x2,y2,z2]叉乘的运算结果是一个向量,并且两个向量的叉积与这两个向量组成的坐标平面垂直,记作axb

    计算方式:利用行列式方式,设i[1,0,0],j[0,1,0],k[0,0,1],则如下图:

    几何解释:axb =  |a| |b| sin \Theta,故两个向量平行,则其叉乘等于零。

    几何意义:叉积的长度|a×b|可以解释成这两个叉乘向量ab共起点时,所构成平行四边形的面积。

    Numpy实现向量的点乘和叉乘

    点乘需要用到numpy库的dot函数,得到一个标量。叉乘需要用到numpy库的cross函数。

    In [1]: import numpu as np   
    In [2]: a = np.array([1,2,3]) 
    In [3]: b = np.array([2,2,3])   
    In [4]: np.dot(a,b)  
    Out[4]: 15
    In [5]: np.cross(a,b)                                                                                                                                            
    Out[5]: array([ 0,  3, -2])
    

    矩阵直接使用*相乘的处理方式是向量对应位置相乘,维数不变,它与np.multiply函数效果一样,均是元素相乘。

    In [6]: a*b               
    Out[6]: array([2, 4, 9])
    In [7]: np.multiply(a,b)                                                                
    Out[7]: array([2, 4, 9])
    

    矩阵


    定义:是一个按照长方阵列排列的复数实数集合。

    • 矩阵点乘:是矩阵各个对应元素相乘, 这个时候要求两个矩阵必须同样大小。
    • 矩阵叉乘:矩阵的乘法就是矩阵a的第m行乘以矩阵b的第n列,各个元素对应相乘然后求和作为第m行n列元素的值。

    Numpy实现矩阵的点乘和叉乘

    矩阵的点乘直接使用*号即可,也可以使用 numpy库的multiply函数,叉乘使用dot函数,这与向量相反

    In [1]: a = np.array([[1,2],[3,4]])                 
    In [2]: b = np.array([[5,6],[7,8]]) 
    In [3]: a*b                                                                                
    Out[3]: 
    array([[ 5, 12],
           [21, 32]])
    In [4]: np.dot(a,b)                                                
    Out[4]: 
    array([[19, 22],
           [43, 50]])
    In [34]: np.multiply(a,b)                                                                                                                                         
    Out[34]: 
    array([[ 5, 12],
           [21, 32]])

    总结Numpy库


    numpy库的对象有数组和矩阵,两者看起来长得差不多,但在性质、运算上有很大不同。可通过array函数mat函数相互转化。

    • dot函数

    对于秩为1的数组,执行对应位置相乘,然后再相加,等价于向量的点乘

    对于秩不为1的二维数组,执行矩阵乘法运算,等价于矩阵的叉乘

    • multiply函数

    数组和矩阵对应位置相乘,输出与相乘数组/矩阵的大小一致,效果上与运算符*对数组效果一样。

    • 运算符*号

    对数组执行对应位置相乘,等价于multiply函数

    对矩阵执行矩阵乘法运算,等价于dot函数

    展开全文
  • 矩阵点乘和叉乘

    万次阅读 2019-08-01 10:26:13
    1、矩阵叉乘 矩阵的乘法就是矩阵a的第一行乘以矩阵b的第一列,各个元素对应相乘然后求和作为第一元素的值。 矩阵只有当左边矩阵的列数等于右边矩阵的行数时,它们才可以相乘,乘积矩阵的行数等于左边矩阵的行数,乘积...
  • numpy中矩阵的点乘和叉乘

    千次阅读 2021-01-28 11:56:38
    点乘: 两个矩阵点乘就是对应元素相乘,要求两个矩阵的行数和列数相等。 import numpy as np a=np.array([[1,2,3],[1,2,3],[1,2,3]]) ...叉乘: 就是矩阵的行的对应元素与列的对应元素相乘再相加,两矩
  • matlab——矩阵点乘,叉乘

    万次阅读 2019-03-08 20:43:51
    什么是点乘,什么是叉乘: 矩阵点乘是对应项,即对应位置的相乘。只有维数相同,且矩阵元素个数相同才能进行点乘。...矩阵直接相乘,是矩阵叉乘。依据线性代数里的矩阵运算法则。 点乘,叉乘分别用在哪里: ...
  • 向量叉乘叉乘矩阵

    万次阅读 多人点赞 2017-02-22 19:04:41
    本文以三维向量来说明向量的叉乘计算原理以及叉乘矩阵如何求取 1、向量叉乘的计算原理 a、b分别为三维向量: a叉乘b一般定义为:
  • 矩阵的点成和叉乘

    2019-01-02 13:46:00
    矩阵叉乘: a =   1 0 2  -1 3 1 b =   3 1  2 1  1 0 c =   5 1  4 2 MATLAB叉乘代码:c=a*b; Python叉乘代码:np.dot(A, B)     矩阵的点乘:(对应位置上的元素相乘,要求两...
  • 矩阵叉乘必须记录下来

    万次阅读 2016-03-07 16:49:02
    一直以来,我都记不住向量叉乘的结果,每次都要查询。其根本原因在于,我没有去研究过叉乘是如何推导出来的。于是,这次想彻底解决一下。首先要感谢维基百科,它已经把所有问题都描述清楚了。 ...
  • 叉乘与反对称矩阵

    万次阅读 多人点赞 2017-12-23 11:13:52
    反对称矩阵定义设A为n维方阵,若有A′=−AA'=-A,则称矩阵A为反对称矩阵。对于反对称矩阵,它的主对角线上的元素全为0,而位于主对角线两侧对称的元素反号。性质 若A为反对称矩阵,则A′,λAA',\lambda A均为反对称...
  • 今天小编就为大家分享一篇Python实现矩阵相乘的三种方法小结,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 矩阵的点乘与叉乘

    千次阅读 2016-07-25 21:18:56
    向量:u=(u1,u2,u3) v=(v1,v2,v3) 叉积公式:u x v = { u2v3-...对于向量的运算,还有两个“乘法”,那就是点乘和叉乘了.点乘的结果就是两个向量的模相乘,然后再与这两个向量的夹角的余弦值相乘.或者说是两个向量的各个
  • 向量 点乘 公式:a ·b = |a| * |b| * cosθ 点乘又叫向量的内积、数量积,是一个向量和它在另一个向量上的投影的长度的乘积;是标量。 点乘反映着两个向量的“相似度”...叉乘 公式:a × b = |a| * |b| * sinθ 叉...
  • #定义正向计算模型,由于为向量需要进行矩阵叉乘,tf.matmul def model(x,w,b): return tf.matmul(x,w)+b pred = model(x,w,b) #定义超参数 train_epochs = 10 learning_rate = 0.01 #定义均方差损失函数 with ...
  • 矩阵和矢量的叉乘推导和简单实用

    千次阅读 2019-02-26 12:55:36
    矩阵叉乘 二维矩阵 假设a(a1,a2) b(b1,b2) aXb = a1b2 - a2b1 几何意义就是 aXb是a b组成的平行四边形的面积 接下来来证明 S(a,b) = ab*Sin&lt;a,b&gt; = b X a = a2b1 - a1b2 Sin&lt;a,b...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,130
精华内容 2,452
关键字:

矩阵叉乘