精华内容
下载资源
问答
  • 在计算函数二阶导的时候,我们通常需要计算Hessian 矩阵,此时会遇到向量求和的问题 ∑i=1nuivi,ui∈Rn×1,vi∈R1×n \sum_{i=1}^n u_i v_i, u_i \in \mathbb{R}^{n\times 1}, v_i \in \mathbb{R}^{1\times n} i...

    在计算函数二阶导的时候,我们通常需要计算Hessian 矩阵,此时会遇到向量外积求和的问题
    ∑ i = 1 n u i v i , u i ∈ R n × 1 , v i ∈ R 1 × n \sum_{i=1}^n u_i v_i, u_i \in \mathbb{R}^{n\times 1}, v_i \in \mathbb{R}^{1\times n} i=1nuivi,uiRn×1,viR1×n
    如果我们一个一个地计算 u i v i u_i v_i uivi 并将它们用for循环加起来,那么我们需要计算 n n n 个矩阵相乘,是非常低效的。
    实际上我们可以将向量外积求和转化成一个矩阵相乘的计算,这里会用到下面的公式
    ∑ i = 1 n u i v i = U V \sum_{i=1}^n u_i v_i = U V i=1nuivi=UV
    这里 u i u_i ui 是矩阵 U U U 的第 i i i 个列向量, v i v_i vi 是矩阵 V V V 的第 i i i 个行向量。 在实际计算中,我们可以构造这样的矩阵,将 n n n 个矩阵计算降低为一个矩阵计算。 下面的代码验证了公式的正确性,并计算了两种方法的时间。

    import numpy as np
    import time
    
    n = 1000
    
    # 创建两个随机矩阵做测试
    U = np.random.rand(n, n)
    V = np.random.rand(n, n)
    
    mat_loop = np.zeros([n, n])
    start = time.time()
    for i in range(n):
        # 向量 u 是矩阵 U 的列向量
        vec_u = U[:, i]
        # 向量 v 是矩阵 V 的行向量
        vec_v = V[i, :]
        # 向量 u, v 做外积
        mat_loop = mat_loop + np.outer(vec_u, vec_v)
    end = time.time()
    print("Time for loop: ", end - start)
    
    start = time.time()
    # 将向量外积求和转化为矩阵相乘
    mat_fast = U @ V
    end = time.time()
    print("Time for vectorizing: ", end - start)
    
    # 因为会有数值计算误差,所以两个矩阵会有一定的误差,但是会很小
    err = np.max(np.abs(mat_loop - mat_fast))
    print("The max difference: ", err)
    

    代码结果
    我们可以看到第二种计算比第一种计算快了大约 600 倍, 他们的结果是一样的。以后遇到向量外积相加的问题,我们可以将其转化为矩阵相乘,这样子可以大大加速计算。

    展开全文
  • 今天小编就为大家分享一篇对numpy中数组转置的求解以及向量内积计算方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Numpy使用了优化的C api,运算速度快,在深度学习需要运用numpy向量化加快运算速度,NumPy底层用C语言编写,内部解除了GIL(全局解释性锁),其对数组的操作速度不受python解释器的限制,效率远高于纯python代码。...

    1、Numpy创建向量

    Numpy创建的数组有时也称为向量,但要注意两者的区别,需要注意数组的秩。
    Numpy使用了优化的C api,运算速度快,在深度学习需要运用numpy向量化加快运算速度,NumPy底层用C语言编写,内部解除了GIL(全局解释性锁),其对数组的操作速度不受python解释器的限制,效率远高于纯python代码。
    原因是Numpy数组由相同种类数据类型的元素组成,可以快速确定存储空间。
    对整组数据进行快速运算的标准数学函数库,无需编写循环,即内置并行运算功能,当系统进行某种计算时,并且有多个核心时,NumPy会自动做并行计算。
    一个大矩阵做运算,for循环是一次提取两个值,放入内存运算后返回结果,再提取2个再运算返回结果。Numpy是一次性把所有值都提入内存同时运算同时返回结果,相当于空间换时间。
    标量计算 --> 串行编程 = 同时只能做一件事,一件接一件(for循环)
    矢量运算 --> 并行编程 = 同时做所有事(向量化)
    标量运算:省空间,费时间
    矢量运算:费空间,省时间

    import numpy as np
    #行向量
    x=np.array([[1,2,3,4]])
    print(x)
    #列向量
    x2=np.array([[1],[2],[3],[4]])
    print(x2)
    #二维向量,矩阵
    y=np.arange(1,9).reshape(2,4)
    print(y)
    #三维向量,矩阵组表,shape(a,b,c)可以理解为a个shape(b,c)的矩阵
    z=np.arange(1,9).reshape(2,2,2)
    print(z)
    
    [[1 2 3 4]]
    [[1]
     [2]
     [3]
     [4]]
    [[1 2 3 4]
     [5 6 7 8]]
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]
    

    注意创建一维向量时,用shape方法查看数组的秩。

    x3=np.array([1,2,3,4])
    x3.shape
    
    (4,)
    
    x.shape
    
    (1, 4)
    
    x3=np.array([[1,2,3,4]])#将其赋值为二维数组
    x3.shape
    
    (1, 4)
    

    x3只是秩为1的数组,x才是一行四列的行向量,
    使用x3在后续进行转置和矩阵乘法等操作时会出现错误。
    在进行矩阵的为了让矩阵操作更加显性化,需要将一维向量用矩阵的形式表示。

    #shape方法查看维度、矩阵行列尺寸
    print(z.shape)
    #size查看元素数量
    print(z.size)
    #ndim查看维度数量,rank秩
    print(z.ndim)#shape中元素个数即为维数,乘积即为矩阵中元素数量
    
    (2, 2, 2)
    8
    3
    

    2、一些方法

    1、合并vstack()、concatenate()

    n1=np.array([[1,2]])
    n2=np.array([[1,2]])
    n3=np.array([[1,2]])
    n4=np.array([[1,2]])
    print(np.vstack((n1,n2)))#向下合并
    print(np.hstack((n1,n2)))#向右合并
    print(np.concatenate((n1,n2,n3),axis=0))#横向
    print(np.concatenate((n1,n2,n3),axis=1))#纵向
    
    [[1 2]
     [1 2]]
    [[1 2 1 2]]
    [[1 2]
     [1 2]
     [1 2]]
    [[1 2 1 2 1 2]]
    

    2、查找最大值和最小值max和min函数,可用axis=0,1,2…控制行列

    print(z)
    #求和
    print(np.sum(z))
    #返回最大
    print(np.max(z))
    #返回最小
    print(np.min(z))
    print(np.min(z,axis=0))#shape(z,x,y)第一个维度"z"最小值
    print(np.min(z,axis=1))#x维度最小行
    print(np.min(z,axis=2))#y维度最小列
    
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]
    36
    8
    1
    [[1 2]
     [3 4]]
    [[1 2]
     [5 6]]
    [[1 3]
     [5 7]]
    

    3、排序、sort(),可用axis=0,1,2…控制行列

    
    # 排序、sort(),可用axis=0,1,2......控制行列 ```
    
    
    ```python
    n5=np.array([[5,3,4,1,2]])
    print(n5)
    print(np.sort(n5))
    n6=np.array([[5,3,4],[1,2,0]])
    print(n6)
    print(np.sort(n6,axis=0))#按行排序(shape中的0行比1行大)
    print(np.sort(n6,axis=1))#按列排序
    
    [[5 3 4 1 2]]
    [[1 2 3 4 5]]
    [[5 3 4]
     [1 2 0]]
    [[1 2 0]
     [5 3 4]]
    [[3 4 5]
     [0 1 2]]
    

    4、分割,split()

    A=np.arange(12).reshape(3,4)
    print(A)
    print(np.split(A,3,axis=0))#横向分割成三块,其中split()中分割的块数只能是行和列的倍数
    print(np.split(A,2,axis=1))#纵向分割成两块
    print(np.vsplit(A,3))#横向分割成三块,其中split()中分割的块数只能是行和列的倍数
    print(np.hsplit(A,2))#纵向分割成两块
    
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
    [array([[0, 1],
           [4, 5],
           [8, 9]]), array([[ 2,  3],
           [ 6,  7],
           [10, 11]])]
    [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
    [array([[0, 1],
           [4, 5],
           [8, 9]]), array([[ 2,  3],
           [ 6,  7],
           [10, 11]])]
    

    5、切片和索引

    #一维数组切片
    a=np.array([1,2,3,4,5,6,7,8])
    #冒号分隔切片
    b=a[0:7:4]#从第初始位置0(1)开始到第7个位置(8)结束
    print(b)
    
    
    [1 5]
    
    #向量化后一维度数组相当于二维行、列向量,属于高维数组
    a1=np.array([[1,2,3,4]])
    print(a1[0])#0相当于第一个维度开始
    print(a1[0,0])#或print(a1[0][0])第一个维度中的第一个元素
    
    
    [1 2 3 4]
    1
    
    a2=np.array([[1,2,3,4]]).reshape(2,2)
    print(a2)
    print(a2[0])
    print(a2[0,:2])#默认从0开始
    
    [[1 2]
     [3 4]]
    [1 2]
    [1 2]
    
    a3=np.arange(9).reshape(3,3)
    print(a3)
    print('切片',a3[:2,2:])#逗号前切行向量,默认从0第一行开始到2第二行结束(不包括第三行)
    #逗号后切列向量,从第三列开始默认从倒数一列结束
    print('切片',a3[1,...])#省略号…切片,省略号表示列
    print('切片',a3[...,1])#省略号表示行
    print(a3[1:2,...])#第二行开始到最后一行元素
    print(a3[...,:1])#第一列到第二列元素
    
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    切片 [[2]
     [5]]
    切片 [3 4 5]
    切片 [1 4 7]
    [[3 4 5]]
    [[0]
     [3]
     [6]]
    
    #三维数组
    a4=np.arange(8).reshape(2,2,2)
    print(a4)
    print('切片',a4[1,1])
    print('索引',a4[0,0,1])
    
    
    [[[0 1]
      [2 3]]
    
     [[4 5]
      [6 7]]]
    切片 [6 7]
    索引 1
    

    6、平均值mean(),方差var(),标准偏差std()

    方差var(){[∑(xn-x帽)^2/n]}(x帽为平均值),
    标准偏差std(),Sqr{[∑(xn-x帽)2/n]},(**公式中∑代表总和,x拨代表x的算术平均值**,2代表二次方,代表平方根。

    a5=np.array([[4,8,8,4]])
    print(np.mean(a5))
    print(np.var(a5))
    print(np.std(a5))
    
    6.0
    4.0
    2.0
    

    7、矩阵的形状和转置

    #reshape()设置行列
    a6=np.array([[0,1,2,3,4,5,6,7]])
    print(a6)
    print(a6.reshape(2,4))
    #转置
    print(a6.reshape(2,4).T)
    
    
    
    [[0 1 2 3 4 5 6 7]]
    [[0 1 2 3]
     [4 5 6 7]]
    [[0 4]
     [1 5]
     [2 6]
     [3 7]]
    

    transpose()三维以上高维数组的transpose()转置方法
    一维、二维中transpose()和.T并无区别
    使用transpose进行多维数组转置时,将shape数组中的数从0开始排序,并称为索引轴,例如三维数组z为(0,1,2),含三个索引轴0,1,2
    然后三个维度/索引轴交换位置,如(1,0,2)是0轴和1轴交换位置

    z=np.arange(8).reshape(2,2,2)
    print(z)
    print(z.transpose(1,0,2))
    #相当于将其降维成的二维矩阵[a,b,c,d],其中a,b,c,d为[0,1],[2,3],[4,5],[6,7]
    #将[0,1],[2,3],[4,5],[6,7]视为一个元素,然后再转置
    print(z.transpose(2,1,0))#z.transpose(2,1,0)=z.T转置
    print(z.transpose(2,0,1))
    
    [[[0 1]
      [2 3]]
    
     [[4 5]
      [6 7]]]
    [[[0 1]
      [4 5]]
    
     [[2 3]
      [6 7]]]
    [[[0 4]
      [2 6]]
    
     [[1 5]
      [3 7]]]
    [[[0 2]
      [4 6]]
    
     [[1 3]
      [5 7]]]
    

    当1(或2)角标与0角标交换时,新建一个矩阵,将0角标作为行,1(或2)角标作为列。构成一个新矩阵(2,2):
    z.transpose(1,0,2)转置对下列矩阵:
    1 2 1 2
    1 [0,1] [2,3]→1 [0,1] [4,5]
    2 [4,5] [6,7]→2 [2,3] [6,7]

    z.transpose(2,1,0)转置对下列矩阵:
    1 2 1 2
    1 [0,1] [2,3]→1 [0,4] [2,6]
    2 [4,5] [6,7]→2 [1,5] [3,7]

    z.transpose(2,0,1)转置对下列矩阵:
    1 2 1 2
    1 [0,1] [2,3]→1 [0,2] [4,6]
    2 [4,5] [6,7]→2 [1,3] [5,7]

    可以写出每个数在轴的具体位置,(0,1,2)对应z、x、y轴如三维数组
    三轴(0,1,2)z中各元素位置:转置成(2,0,1),相当于z轴换成原来的y轴,x轴换成原来的z轴,y轴换成原来的x轴,
    轴 z,x,y z, x, y z.transpose(2,0,1)
    0 (0,0,0) (0,0,0) 找 0
    1 (0,0,1) (1,0,0) 到 2
    2 (0,1,0) (0,0,1) 重 4 →【【【0 2】
    3 (0,1,1) (1,0,1) 置 6 → 【4 6】
    4 (1,0,0) (0,1,0) 后 1 → 【1 3】
    5 (1,0,1) (1,1,0) 新 3 → 【5,7】】】
    6 (1,1,0) (0,1,1) 位 5
    7 (1,1,1) (1,1,1) 值 7

    例如1原本在001位置,转置后到了100位置,那么它的新位置
    参照原先的轴z,x,y就是原先的4的位置

    #swapaxes()方法
    #接收轴编号,对应轴进行交换,只能接受两个轴的对换
    z.swapaxes(1,0)#相当于z.transpose(1,0,2)
    
    array([[[0, 1],
            [4, 5]],
    
           [[2, 3],
            [6, 7]]])
    

    8、矩阵的特征值(eigenvalues)和特征向量(eigenvectors)

    Av =K(λ)v,A为方阵(行列都相等),K为特征值,v为特征向量

    a7=np.arange(8).reshape(2,2,2)
    print(a7)
    eigenvalues ,eigenvectors=np.linalg.eig(a7)
    print(eigenvalues)
    print(eigenvectors)
    
    [[[0 1]
      [2 3]]
    
     [[4 5]
      [6 7]]]
    [[-0.56155281  3.56155281]
     [-0.17890835 11.17890835]]
    [[[-0.87192821 -0.27032301]
      [ 0.48963374 -0.96276969]]
    
     [[-0.76729658 -0.57152478]
      [ 0.64129241 -0.82058481]]]
    

    9、矩阵的运算

    b2 =np.arange(9).reshape(3,3)
    b3=b2.T
    print(b2)
    print(b3)
    
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    [[0 3 6]
     [1 4 7]
     [2 5 8]]
    
    #add()矩阵加法
    print(np.add(b2,b3))
    #subtract()减法
    print(np.subtract(b2,b3))
    #数量积*(行*行)
    print(b2*b3)#np.multiply(b2,b3)乘法
    #dot()向量积/点积(行*列)
    print(np.dot(b2,b3))
    
    
    [[ 0  4  8]
     [ 4  8 12]
     [ 8 12 16]]
    [[ 0 -2 -4]
     [ 2  0 -2]
     [ 4  2  0]]
    [[ 0  3 12]
     [ 3 16 35]
     [12 35 64]]
    [[  5  14  23]
     [ 14  50  86]
     [ 23  86 149]]
    

    10、矩阵的逆运算AB=BA=E

    E为单位矩阵,A、B两矩阵互为逆矩阵,也称A是B的逆矩阵

    z1= np.array([[1,2,3],[4,5,6],[7,8,9]])
    print(z1)
    #np.linalg.inv()求逆函数
    print(np.linalg.inv(z1))
    
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    [[ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]
     [-6.30503948e+15  1.26100790e+16 -6.30503948e+15]
     [ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]]
    
    展开全文
  • Python/Numpy之点叉积内积张量 内积内积、标量、数量、点、点乘)a与b的内积为 a·b = |a||b|cos∠(a, b),结果为标量(一个数) 外(叉乘):向量a与b的外a×b是一个向量,其长度等于|a×b| =...

    Python/Numpy之点积叉积内积外积张量积

    内积(内积、标量积、数量积、点积、点乘)a与b的内积为 a·b = |a||b|cos∠(a, b),结果为标量(一个数)
    外积(叉乘):向量a与b的外积a×b是一个向量,其长度等于|a×b| = |a||b|sin∠(a,b),其方向正交于a与b。并且,(a,b,a×b)构成右手系。(外积是张量积的一种形式)
    张量积:Kronecker product a⊗b

    1.内积、外积、张量积、对应元素相乘

    1. 内积:innerx = np.dot(arr1,arr2)
    2. 外积:outerx = np.outer(arr1,arr2)
    3. 张量积:kronx = np.kron(arr1,arr2)
    4. 对应元素相乘:mul = arr1 * arr2 # 只有这种方式是元素相乘,其余都是矩阵相乘运算规则

    2. 举例如下

    >>> arr1 = np.array([1,2,3])
    >>> arr2 = np.array([2,3,4])
    # 外积
    >>> outerx = np.outer(arr1,arr2)
    >>> outerx
    array([[ 2,  3,  4],
           [ 4,  6,  8],
           [ 6,  9, 12]])
    # 内积
    >>> dotx = np.dot(arr1,arr2)
    >>> dotx
    20
    # 张量积
    >>> kronx = np.kron(arr1,arr2)
    >>> kronx
    array([ 2,  3,  4,  4,  6,  8,  6,  9, 12])
    # 对应元素乘积
    >>> mul = a * b
    >>> mul
    array([1, 4, 9])
    

    更多Python数据科学相关见专题Python数据科学技能索引
    点乘与叉乘
    向量内积外积,为啥要叫「内」「外」?
    python实现矢量积、叉积、外积、张量积

    展开全文
  • numpy向量,矩阵,数组

    2021-10-18 01:57:16
    import numpy as np from numpy import ma from numpy.core.fromnumeric import shape #创建一个行向量 list_row = np.array([1.0,2.0,3.0]) list_row #%% #创建一个列向量 list_column = np.array([[1.0],[2.0],...

    #%%
    import numpy as np
    from numpy import ma
    from numpy.core.fromnumeric import shape
    #创建一个行向量
    list_row = np.array([1.0,2.0,3.0])
    list_row
    #%%
    #创建一个列向量
    list_column = np.array([[1.0],[2.0],[3.0]])
    list_column
    #%%
    # 创建一个矩阵
    matrix = np.array([[1, 2],[1, 2],[1, 2]])
    matrix
    #%%
    from scipy import sparse
    #加载稀疏矩阵
    #%%
    matrix_s = np.array([[0, 0],[0, 1],[3, 0]])
    matrix_s
    #%%
    #创建一个压缩的稀疏行(Compressed Sparse Row,CSR)矩阵
    matrix_sparse = sparse.csr_matrix(matrix_s)
    print(matrix_sparse)
    #%%
    matrix_large = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\
        [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\
        [3, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
    matrix_large
    #%%
    matrix_large_sparse = sparse.csr_matrix(matrix_large)
    print(matrix_large_sparse)
    #%%
    matrix_large_other = np.array([[5, 6, 0, 0, 0, 0, 0, 0, 0, 0],\
        [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\
        [3, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
    matrix_large_other_sparse = sparse.csr_matrix(matrix_large_other)
    print(matrix_large_other_sparse)
    #%%
    #numpy直接索引取值,可以避免循环遍历
    matrix1 = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
    matrix1[1,2]
    #%%
    matrix1[2:]
    #%%
    #shape、size 和 ndim 函数
    #形状
    print(matrix1.shape)
    #元素个数:行*列
    print(matrix1.size)
    #矩阵维度
    print(matrix1.ndim)
    #%%
    #对所有矩阵元素执行指定操作
    #通过自定义函数,或者lambda表达式
    #创建一个向量化函数并操作矩阵:
    function_one = np.vectorize(lambda x:x**2)
    function_one(matrix1)
    #%%
    #最值:max,min
    np.max(matrix1)
    #%%
    np.max(matrix1[:1])
    #%%
    matrix1
    #%%
    matrix1.T
    #%%
    print(np.max(matrix1.T[1:]))
    #%%
    matrix2 = np.array([[51, 23, 3],[4, 15, 62],[47, 18, 39]])
    matrix2
    #%%
    #列维度
    np.max(matrix2,axis=0)
    #%%
    #行维度
    np.min(matrix2,axis=1)
    #%%
    #平均值:mean、方差:var 和 标准差:std
    #同样可以使用上面的维度,也可以操作整个ndarray
    np.mean(matrix2)
    #%%
    np.var(matrix2)
    #%%
    np.std(matrix2,axis=0)
    #%%
    #矩阵的变形
    matrix3 = np.array([[51, 23, 3],[4, 15, 62],[47, 18, 39],[23,25,24]])
    matrix3.reshape(2,6)
    #%%
    matrix2.size
    #%%
    matrix2.reshape(1,-1)
    #等价于flatten
    #%%
    matrix2.flatten()
    #%%
    #矩阵转置
    matrix2[2:].T
    #%%
    matrix2
    #%%
    matrix2.T[2:]
    #%%
    #矩阵的秩
    matrix4 = np.array([[1, 1, 1],[1, 1, 1],[1, 1, 1]])
    np.linalg.matrix_rank(matrix4)
    #计算行列式
    np.linalg.det(matrix4)
    #获取对角元素
    print(matrix2)
    matrix2.diagonal()
    #%%
    #对角线向上偏移
    matrix2.diagonal(offset=1)
    #对角线向下偏移
    matrix2.diagonal(offset=-1)
    #矩阵的迹:对角线元素的和:常被用在机器学习方法的底层计算
    print(matrix2.trace())
        #同样可用对角线求和:
    sum(matrix2.diagonal())
    
    #计算特征值和特征向量
    #%%
    matrix5 = np.array([[1, -1, 3],[1, 1, 6],[3, 8, 9]])
    eigenvalues,eigenvectors = np.linalg.eig(matrix5)
    print(eigenvalues)
    print(eigenvectors)
    
    #%%
    #矩阵点积
    vector_a = np.array([1,2,3])
    vector_b = np.array([4,5,6])
    print(np.dot(vector_a,vector_b))
    vector_a@vector_b
    #%%
    #加减乘除为对应相加相减相乘相除
    vector_a/vector_b
    #%%
    #矩阵的逆
    print(matrix2)
    np.linalg.inv(matrix2)
    
    #%%
    #伪随机数生成
    #生成随机数种子
    """
    多次返回相同的随机数对于获取可预测、可重复的结果是很有用的。
    如果希望多次返回同样的随机数,
    可以设置伪随机数生成器的“种子”(一个整数)。
    如果在程序中用到了随机数,
    则拥有相同“种子”的程序会生成同样的结果。
    """
    np.random.seed(0)
    #%%
    #生成3个0.0到1.0之间的随机浮点数
    np.random.random(3)
    #%%
    #生成3个0到10之间的随机整数
    np.random.randint(0, 11, 3)
    #%%
    #从平均值是1.1且标准差是2.0的正态分布中抽取5个数
    np.random.normal(1.1, 2.0, 5)
    #%%
    #从平均值是0.0且分散程度是1.0的logistics分布中抽取3个数
    np.random.logistic(0.0, 1.0, 3)
    #从大于或等于11.0并且小于12.0的范围中抽取4个数
    np.random.uniform(11.0, 12.0, 4)

     

     

    展开全文
  • numpy 向量/矩阵的乘法

    千次阅读 2019-04-09 17:36:06
    一维向量与一维向量 #------------一维向量与一维向量------------------# vec1 = np.array([1, 2, 3]) vec2 = np.array([4, 5, 6]) # np.inner() 对应位置的元素相乘相加求和 res_inner1 = np.inner(vec1, vec2) ...
  • 向量内积/点

    2019-12-05 10:50:41
    向量内积/点向量空间Rn中,自然基下,向量x=(x1,…,xn)和y=(y1,…,yn)在向量空间\mathbb{R}^n中,自然基下,向量\boldsymbol{x}=(x_1,\ldots,x_n)和 \boldsymbol{y}=(y_1,\ldots,y_n)在向量空间Rn中,自然基下...
  • 线性代数向量内积Prerequisites: 先决条件: Defining Vector using Numpy 使用Numpy定义向量 Learn: how to code for outer product of two vectors using am inbuilt function in numpy library? 了解:如何...
  • numpy.outer 计算向量

    千次阅读 2020-07-07 17:55:22
    numpy 中的外定义和数学中是不同的,其定义如下 示例 import numpy as np r=np.outer(np.arange(1,4), [5,2,1,4]) 结果 array([[ 5, 2, 1, 4], [10, 4, 2, 8], [15, 6, 3, 12]])
  • 有点抱歉的是我的数学功底...不过,关于内积倒是查到了一个几何解释,而且不知道其对不对。解释为:高维空间的向量到低维子空间的投影,但是思索了好久依然是没有弄明白。看来,线性代数还是得闷头好好理解一下咯。
  • 1、创建一个数组时,不要使用命令 a= np.random.randn(5), 这种命令生成的数据结构为(5,),秩为1,既不是行...而如果我输出a和a的转置阵的内积,你可能会想:a乘以a的转置返回给你的可能会是一个矩阵。但是如果我...
  • 觉得有用的话,欢迎一起讨论相互学习~Follow Me2.11向量向量化是消除代码中显示for循环语句的艺术,在训练大数据集时,深度学习算法才变得高效,所以代码运行的非常快十分重要.所以在深度学习领域中将大数据集进行向量...
  • 三维点云学习(8)6-3D Feature Description numpy 向量点乘、叉乘、星乘 ;...##向量内积 点乘 ,结果是实数 c1 = np.dot(a1,b1) print(c1) #out: 3 向量叉乘 np.cross d1 = np.cross(a1,b1) print(d
  • 线性代数向量内积Prerequisite: Linear Algebra | Defining a Vector 先决条件: 线性代数| 定义向量 Linear algebra is the branch of mathematics concerning linear equations by using vector spaces and ...
  • 文章目录2.15 Python 中的广播(Broadcasting in Python)2.16 关于 python _ numpy 向量的说明(A note on python or numpy vectors) 2.15 Python 中的广播(Broadcasting in Python) 这是一个不同食物(每100g)中...
  • Numpy-向量操作

    2021-06-17 20:41:20
    1 计算函数 NumPy 中都包含大量数学函数可直接使用 点与叉积 三角函数: 取近似值: 2 统计函数 求一般统计值, .argmax(), .argmin() 返回索引值 3 排序
  • 2.16 A note on Python_numpy vectors(关于 python _ numpy 向量的说明) (字幕来源:网易云课堂) The ability of python to allow you to use broadcasting operations and more generally,the great ...
  • 用SSE做向量内积

    2018-01-14 21:57:00
    SSE是Streaming SIMD Extensions的缩写,SIMD是Single Instruction ...从SSE4.1开始支持向量内积:__m128 _mm_dp_ps( __m128 a,__m128 b,const int mask)。更老的版本需要综合运用多条指令才可以办到。_m128表示1...
  • numpy 矩阵(点

    万次阅读 2018-08-23 14:29:01
    NumPy中dot()函数的理解 今天学习到numpy基本的运算方法,遇到了一个让我比较难理解的问题。就是dot函数是如何对矩阵进行运算的。 一、dot()的使用 ...dot()返回的是两个数组的点(dot product) 1.如果...
  • Numpy向量与标量计算

    千次阅读 2019-05-18 16:07:28
    import numpy as np a=np.array([1,2,3]) b=np.array([3,2,1]) print (a+10) #对应位置依次相加 print (a*2) print ([1,2,3]*2) print (a+b) print (a-b) print (a*b) print (a/b) print (a*...
  • 最近在熟悉python的科学计算,对于...np.dot(a,b),但a,b都为一维矩阵的时候,.dot实现内积,不用考虑a,b具体是行向量还是列向量,也就是说,a,b同为行向量仍然可以计算 a.dot(b) a@b 2、各个元素相乘 a*b ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,209
精华内容 3,683
关键字:

numpy向量内积