zoukankan      html  css  js  c++  java
  • 矩阵运算

    向量的乘法有两种,分别成为内积外积.

    内积也称数量积,因为其结果为一个数(标量)
    向量a,b的内积为|a|*|b|cos,其中表示a与b的夹角
    向量外积也叫叉乘,其结果为一个向量,方向是按右手系垂直与a,b所在平面|a|*|b|sin

     外积:元素对应乘积 ,Hadamard 乘积  ,  A的形状m*n, B的形状 n*j, C的形状为 m*j

     

    a1=np.arange(6).reshape(3,2)
    b1=np.arange(6).reshape(2,3)
    print a1,'
    ',b1
    print np.dot(a1,b1)
    [[0 1]
     [2 3]
     [4 5]] a1 
    [[0
    1 2] [3 4 5]] b1
    [[
    3 4 5] [ 9 14 19] [15 24 33]]

     性质:

    服从分配率

    服从结合率

    乘积转置

    python中矩阵的一些操作:

    #!/usr/bin/python
    #coding=utf-8
    #__author__='dahu'
    #官网https://docs.scipy.org/doc/numpy-dev/reference/arrays.classes.html#matrix-objects
    import numpy as np
    a=np.mat('1 2 3; 4 5 3')        #以分号结尾的生成形式
    print a
    
    #常见矩阵
    print np.mat(np.zeros((3,4))),'全0'
    print np.mat(np.ones((3,4))),'全1'
    print np.mat(np.eye(3,4)),'单位矩阵'   #单位矩阵,注意单位矩阵的输入格式跟上面两个不一样
    print np.mat(np.diag(range(5))),'对角矩阵'
    
    print np.mat(np.random.rand(2,3)),'创建2行3列的矩阵,每个元素的大小在0,1之间'
    print np.mat(np.random.randint(1,5,size=(3,4))),'创建3行4列矩阵,每个元素范围在[1,5)'
    
    #矩阵运算
    a1=np.arange(6).reshape(3,2)
    a1=np.mat(a1)                   #注意mat也是工厂函数,继承于ndarray
    b1=np.mat(np.arange(6).reshape(2,3))
    print a1,'a1
    ',b1.T,'b1转置'
    print np.multiply(a1,b1.T),'俩矩阵对应元素相乘,俩矩阵列的个数要相等'
    print a1*2                ,'矩阵乘标量,点乘'
    print np.dot(a1,b1)       ,'矩阵叉乘,前一个的列和后一个的行相等'
    
    #矩阵操作
    print a1.T  ,'转置'
    print a1.H  ,'共轭转置'
    print a1.I  ,'逆矩阵'
    print np.dot(a1.I,a1),'矩阵的逆叉乘矩阵,为单位矩阵'
    print a1.A,type(a1.A),'去除矩阵格式,返回数组'
    
    #计算矩阵对应行列的最大、最小值、和
    print a1.sum(),'全部求和'
    print a1.sum(axis=0),'列和,2列求和,行就抵消了,返回1行2列的矩阵'
    print a1.sum(axis=1),'行和,3行求和,返回3行1列的矩阵'
    print a1.max(),'数值,a1矩阵中所有元素的最大值'
    print np.max(a1,0),'a1矩阵中各列的最大值组成一个1行多列的矩阵'
    print np.max(a1,1),'行的最大值'
    print np.argmax(a1,0),'列的最大值在该列中的索引'
    
    #矩阵的分隔和合并
    c=np.mat(np.ones((3,3)))
    print c[1:,1:],'分割,第二行和第二列以后所有的元素'
    d1=np.mat(np.ones((2,2)))
    d2=np.mat(np.eye(2))
    print np.vstack((d1,d2)),'按列合并,增加行数'
    print np.hstack((d1,d2)),'按hang合并,增加列数'
    
    #矩阵,数组,列表互相转换
    >>>a1=[[1,2],[3,2],[5,2]]  #列表
    >>> a1
    [[1, 2], [3, 2], [5, 2]]
    >>>a2=array(a1)  #将列表转换成二维数组
    >>> a2
    array([[1, 2],
           [3, 2],
           [5, 2]])
    >>>a3=mat(a1)  #将列表转化成矩阵
    >>> a3
    matrix([[1, 2],
            [3, 2],
            [5, 2]])
    >>>a4=array(a3)  #将矩阵转换成数组
    >>> a4
    array([[1, 2],
           [3, 2],
           [5, 2]])
    >>>a41=a3.getA()  #将矩阵转换成数组
    >>>a41
    array([[1,2]
           [3,2]
           [5,2]])
    >>>a5=a3.tolist()  #将矩阵转换成列表
    >>> a5
    [[1, 2], [3, 2], [5, 2]]
    >>>a6=a2.tolist()  #将数组转换成列表
    >>> a6
    [[1, 2], [3, 2], [5, 2]]
    /usr/bin/python2.7 /home/dahu/Homework/GMM的EM算法实现/矩阵练习.py
    [[1 2 3]
     [4 5 3]]
    [[ 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.  0.  0.  0.]
     [ 0.  1.  0.  0.]
     [ 0.  0.  1.  0.]] 单位矩阵
    [[0 0 0 0 0]
     [0 1 0 0 0]
     [0 0 2 0 0]
     [0 0 0 3 0]
     [0 0 0 0 4]] 对角矩阵
    [[ 0.49413545  0.30732574  0.99311351]
     [ 0.18276303  0.84983583  0.00383651]] 创建2行3列的矩阵,每个元素的大小在0,1之间
    [[3 3 1 3]
     [1 3 4 2]
     [1 2 3 2]] 创建3行4列矩阵,每个元素范围在[1,5)
    [[0 1]
     [2 3]
     [4 5]] a1
    [[0 3]
     [1 4]
     [2 5]] b1转置
    [[ 0  3]
     [ 2 12]
     [ 8 25]] 俩矩阵对应元素相乘,俩矩阵列的个数要相等
    [[ 0  2]
     [ 4  6]
     [ 8 10]] 矩阵乘标量,点乘
    [[ 3  4  5]
     [ 9 14 19]
     [15 24 33]] 矩阵叉乘,前一个的列和后一个的行相等
    [[0 2 4]
     [1 3 5]] 转置
    [[0 2 4]
     [1 3 5]] 共轭转置
    [[-1.08333333 -0.33333333  0.41666667]
     [ 0.83333333  0.33333333 -0.16666667]] 逆矩阵
    [[  1.00000000e+00   9.43689571e-16]
     [ -3.33066907e-16   1.00000000e+00]] 矩阵的逆叉乘矩阵,为单位矩阵
    [[0 1]
     [2 3]
     [4 5]] <type 'numpy.ndarray'> 去除矩阵格式,返回数组
    15 全部求和
    [[6 9]] 列和,2列求和,行就抵消了,返回1行2列的矩阵
    [[1]
     [5]
     [9]] 行和,3行求和,返回3行1列的矩阵
    5 数值,a1矩阵中所有元素的最大值
    [[4 5]] a1矩阵中各列的最大值组成一个1行多列的矩阵
    [[1]
     [3]
     [5]] 行的最大值
    [[2 2]] 列的最大值在该列中的索引
    [[ 1.  1.]
     [ 1.  1.]] 分割,第二行和第二列以后所有的元素
    [[ 1.  1.]
     [ 1.  1.]
     [ 1.  0.]
     [ 0.  1.]] 按列合并,增加行数
    [[ 1.  1.  1.  0.]
     [ 1.  1.  0.  1.]] 按hang合并,增加列数
    
    Process finished with exit code 0
  • 相关阅读:
    C++入门经典-例8.5-多重继承
    C++入门经典-例8.3-子类显示调用父类构造函数
    C++入门经典-例8.2-构造函数的访问顺序
    C++入门经典-类成员的可访问性,继承后的可访问性
    C++入门经典-例8.1-类的继承
    C++入门经典-例7.10-运算符的重载,重载加号运算符
    C++入门经典-例7.9-对象数组,批量化生产
    C++入门经典-例7.8-const对象,标准尺寸
    C++入门经典-例7.7-对象与复制,菌类的繁殖
    C++入门经典-例7.6-this指针,同一个类的不同对象数据
  • 原文地址:https://www.cnblogs.com/dahu-daqing/p/6821403.html
Copyright © 2011-2022 走看看