精华内容
下载资源
问答
  • 向量范数与矩阵范数定义和python相关运算示例1.范数(norm)的意义要更好的理解范数,就要从函数、几何与矩阵的角度去理解。 我们都知道,函数与几何图形往往是有对应的关系,这个很好想象,特别是在三维以下的空间内...

    向量范数与矩阵范数定义和python向量矩阵运算示例

    1.范数(norm)的意义

    要更好的理解范数,就要从函数、几何与矩阵的角度去理解。 
    我们都知道,函数与几何图形往往是有对应的关系,这个很好想象,特别是在三维以下的空间内,函数是几何图像的数学概括,而几何图像是函数的高度形象化,比如一个函数对应几何空间上若干点组成的图形。 
    但当函数与几何超出三维空间时,就难以获得较好的想象,于是就有了映射的概念,映射表达的就是一个集合通过某种关系转为另外一个集合。通常数学书是先说映射,然后再讨论函数,这是因为函数是映射的一个特例。 
    为了更好的在数学上表达这种映射关系,(这里特指线性关系)于是就引进了矩阵。这里的矩阵就是表征上述空间映射的线性关系。而通过向量来表示上述映射中所说的这个集合,而我们通常所说的基,就是这个集合的最一般关系。于是,我们可以这样理解,一个集合(向量),通过一种映射关系(矩阵),得到另外一个几何(另外一个向量)。 
    那么向量的范数,就是表示这个原有集合的大小。 
    而矩阵的范数,就是表示这个变化过程的大小的一个度量。

    总结起来一句话,范数(norm),是具有“长度”概念的函数。

    2.范数满足的三个特性

    1.非负性: ||x||0||x||≥0,且||x||=0||x||=0当且仅当x=0x=0时成立 。 
    2.齐次性: ||kx||=|k|||x||||k⋅x||=|k|⋅||x|| 
    3.三角不等式: ||x+y||||x||+||y||||x+y||≤||x||+||y||

    3.向量的范数

    1-范数,计算方式为向量所有元素的绝对值之和。 

    ||x||1=in|xi|||x||1=∑in|xi|

    2-范数,计算方式跟欧式距离的方式一致。 
    ||x||2=(i=1n|xi|2)12||x||2=(∑i=1n|xi|2)12

    -范数,所有向量元素中的最大值。 
    ||x||=maxi|xi|||x||∞=maxi|xi|

    −∞-范数,所有向量元素中的最小值。 
    ||x||=mini|xi|||x||−∞=mini|xi|

    pp-范数,所有向量元素绝对值的p次方和的1/p次幂。 
    ||x||p=(i=1n|xi|p)1p||x||p=(∑i=1n|xi|p)1p

    4.矩阵的范数

    首先假设矩阵的大小为mnm∗n,即m行n列。

    1-范数,又名列和范数。顾名思义,即矩阵列向量中绝对值之和的最大值。 

    ||A||1=maxji=1m|aij|||A||1=maxj∑i=1m|aij|

    2-范数,又名谱范数,计算方法为ATAATA矩阵的最大特征值的开平方。 
    ||A||2=λ1||A||2=λ1

    其中λ1λ1ATAATA的最大特征值。

    -范数,又名行和范数。顾名思义,即矩阵行向量中绝对值之和的最大值。 

    ||A||=maxji=1n|aij|||A||∞=maxj∑i=1n|aij|

    F-范数,Frobenius范数,计算方式为矩阵元素的绝对值的平方和再开方。 

    ||A||F=(i=1mj=1n|aij|2)12||A||F=(∑i=1m∑j=1n|aij|2)12

    5.在python里计算范数

    numpy包里的linalg模块,是专门处理基本线性代数问题的模块。借助该模块中的norm()函数可以轻松计算向量与矩阵的范数。

    先看看norm()方法的原型:

    def norm(x, ord=None, axis=None, keepdims=False):
        """
        Matrix or vector norm.
    
        This function is able to return one of eight different matrix norms,
        or one of an infinite number of vector norms (described below), depending
        on the value of the ``ord`` parameter.
    
        Parameters
        ----------
        x : array_like
            Input array.  If `axis` is None, `x` must be 1-D or 2-D.
        ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
            Order of the norm (see table under ``Notes``). inf means numpy's
            `inf` object.
        axis : {int, 2-tuple of ints, None}, optional
            If `axis` is an integer, it specifies the axis of `x` along which to
            compute the vector norms.  If `axis` is a 2-tuple, it specifies the
            axes that hold 2-D matrices, and the matrix norms of these matrices
            are computed.  If `axis` is None then either a vector norm (when `x`
            is 1-D) or a matrix norm (when `x` is 2-D) is returned.
        keepdims : bool, optional
            If this is set to True, the axes which are normed over are left in the
            result as dimensions with size one.  With this option the result will
            broadcast correctly against the original `x`.
    
            .. versionadded:: 1.10.0
    
        Returns
        -------
        n : float or ndarray
            Norm of the matrix or vector(s).
    
        Notes
        -----
        For values of ``ord <= 0``, the result is, strictly speaking, not a
        mathematical 'norm', but it may still be useful for various numerical
        purposes.
    
        The following norms can be calculated:
    
        =====  ============================  ==========================
        ord    norm for matrices             norm for vectors
        =====  ============================  ==========================
        None   Frobenius norm                2-norm
        'fro'  Frobenius norm                --
        'nuc'  nuclear norm                  --
        inf    max(sum(abs(x), axis=1))      max(abs(x))
        -inf   min(sum(abs(x), axis=1))      min(abs(x))
        0      --                            sum(x != 0)
        1      max(sum(abs(x), axis=0))      as below
        -1     min(sum(abs(x), axis=0))      as below
        2      2-norm (largest sing. value)  as below
        -2     smallest singular value       as below
        other  --                            sum(abs(x)**ord)**(1./ord)
        =====  ============================  ==========================

    我的例子:

    #!/usr/bin/env python
    # coding:utf-8
    import numpy as np
    import numpy.linalg as LA
    
    def compute_norm():
        mat = np.matrix([[1,2],[3,4]])
        print "mat:\n", mat
        inv_mat = np.linalg.inv(mat)
        print "inv_mat:\n",inv_mat
    
    def vector_norm():
        a = np.arange(9) - 4
        print a
        print LA.norm(a, np.inf)  # 无穷范数
        print LA.norm(a, -np.inf)  # 负无穷范数
        print LA.norm(a, 1)  # 1范数
        print LA.norm(a, 2)  # 2范数
    
    def matrix_norm():
        a = np.arange(9) - 4
        print a
        b = a.reshape(3, 3)
        print "b:\n",b
        b_t = np.transpose(b)
        print "b_t:\n",b_t
        b_new = np.dot(b_t, b)  # b_new矩阵为b^t * b
        print "b_new:\n",b_new
    
        x_eigvals = np.linalg.eigvals(b_new)  # 求b_new矩阵的特征值
        print "x_eigvals:\n",x_eigvals
    
        print LA.norm(b, 1)  # 列范数
        print LA.norm(b, 2)  # 谱范数,为x里最大值开平方
        print LA.norm(b, np.inf)  # 无穷范数,行范数
        print LA.norm(b, "fro")  # F范数
    print "数组转换为矩阵及矩阵求逆:\n"
    compute_norm()
    print "向量范数相关运算:\n"
    vector_norm()
    print "矩阵范数相关运算:\n"
    matrix_norm()

    结果如下:

    数组转换为矩阵及矩阵求逆:
    
    mat:
    [[1 2]
     [3 4]]
    inv_mat:
    [[-2.   1. ]
     [ 1.5 -0.5]]
    向量范数相关运算:
    
    [-4 -3 -2 -1  0  1  2  3  4]
    4.0
    0.0
    20.0
    7.74596669241
    矩阵范数相关运算:
    
    [-4 -3 -2 -1  0  1  2  3  4]
    b:
    [[-4 -3 -2]
     [-1  0  1]
     [ 2  3  4]]
    b_t:
    [[-4 -1  2]
     [-3  0  3]
     [-2  1  4]]
    b_new:
    [[21 18 15]
     [18 18 18]
     [15 18 21]]
    x_eigvals:
    [  5.40000000e+01   6.00000000e+00   5.99792822e-16]
    7.0
    7.34846922835
    9.0
    7.74596669241
    
    Process finished with exit code 0

    numpy中mat和python的list转换例子

    >>> import numpy
    >>> a=[[1,2],[3,4],[5,6]]
    >>> a
    [[1, 2], [3, 4], [5, 6]]
    >>> b=numpy.mat(a)
    >>> b
    matrix([[1, 2],
            [3, 4],
            [5, 6]])
    >>> c=b.tolist()
    >>> c
    [[1, 2], [3, 4], [5, 6]]

    参考:https://blog.csdn.net/bitcarmanlee/article/details/51945271

    展开全文
  • Python中,列表支持与整数的乘法运算,但表示的是列表元素的重复,并生成新列表,如:>>> [1,2,3]*3[1, 2, 3, 1, 2, 3, 1, 2, 3]Python列表不支持与整数的加、减、除运算,也不支持列表之间的减、乘、除操作,而...

    在Python中,列表支持与整数的乘法运算,但表示的是列表元素的重复,并生成新列表,如:

    >>> [1,2,3]*3

    [1, 2, 3, 1, 2, 3, 1, 2, 3]

    Python列表不支持与整数的加、减、除运算,也不支持列表之间的减、乘、除操作,而加法运算则表示列表元素的合并,并生成新列表,如:

    >>> [1,2,3]+[4,5,6]

    [1, 2, 3, 4, 5, 6]

    对于向量而言,经常需要这样的操作,例如向量所有分量同时加、减、乘、除同一个数,或者向量之间的加、减、乘、除运算,Python列表不支持这样的操作,但可以借助于内置函数或运算符模块来实现,如:

    >>> import random

    >>> x = [random.randint(1,100) for i in range(10)] #生成10个介于[1,100]之间的随机数

    >>> x

    [46, 76, 47, 28, 5, 15, 57, 29, 9, 40]

    >>> x = list(map(lambda i: i+5, x)) #所有元素同时加5

    >>> x

    [51, 81, 52, 33, 10, 20, 62, 34, 14, 45]

    >>> x = list(map(lambda i: i//5, x)) #所有元素同时对5求整商

    >>> x

    [10, 16, 10, 6, 2, 4, 12, 6, 2, 9]

    >>> x = [random.randint(1,10) for i in range(10)]

    >>> x

    [2, 2, 9, 6, 7, 9, 2, 1, 2, 7]

    >>> y = [random.randint(1,10) for i in range(10)]

    >>> y

    [8, 1, 9, 7, 1, 5, 8, 4, 1, 9]

    >>> import operator

    >>> z = sum(map(operator.mul, x, y)) #向量内积

    >>> z

    278

    >>> list(map(operator.add, x, y)) #向量对应元素相加

    [10, 3, 18, 13, 8, 14, 10, 5, 3, 16]

    >>> list(map(operator.sub, x, y))

    [-6, 1, 0, -1, 6, 4, -6, -3, 1, -2]

    >>> x = [random.randint(1,10) for i in range(5)]

    >>> x

    [1, 7, 9, 10, 2]

    >>> list(map(operator.add, x, [3 for i in range(len(x))])) #向量所有元素同时加3

    [4, 10, 12, 13, 5]

    展开全文
  • python 向量之间的运算

    千次阅读 2015-03-28 16:38:00
    向量转置 http://stackoverflow.com/questions/5954603/python-numpy-transpose 转载于:https://www.cnblogs.com/hope100/p/4374421.html

    向量转置

    http://stackoverflow.com/questions/5954603/python-numpy-transpose

    转载于:https://www.cnblogs.com/hope100/p/4374421.html

    展开全文
  • #生成一个整数的等差序列#局限,只能用于遍历r1_10 = range(1, 10, 2)for i in r1_10:print(i)r1_10 = range(0.1, 10, 2)#生成一个小数的等差序列import numpynumpy.a... 0.01)#向量化计算,四则运算a=r + rb=r -...

    ad8933dd6407

    ad8933dd6407

    ad8933dd6407

    ad8933dd6407

    ad8933dd6407

    #生成一个整数的等差序列

    #局限,只能用于遍历

    r1_10 = range(1, 10, 2)

    for i in r1_10:

    print(i)

    ad8933dd6407

    r1_10 = range(0.1, 10, 2)

    ad8933dd6407

    #生成一个小数的等差序列

    import numpy

    numpy.arange(0.1, 0.5, 0.01)

    ad8933dd6407

    r = numpy.arange(0.1, 0.5, 0.01)

    ad8933dd6407

    #向量化计算,四则运算

    a=r + r

    b=r - r

    c=r * r

    d=r / r

    #函数式的向量化计算

    numpy.power(r, 5)#r的五次方

    #向量化运算,比较运算

    r>0.3

    #结合过滤进行使用

    r[r>0.3]

    #矩阵运算

    numpy.dot(r, r.T)

    ad8933dd6407

    sum(r*r)

    from pandas import DataFrame

    df = DataFrame({

    'column1': numpy.random.randn(7),

    'column2': numpy.random.randn(7)

    })

    ad8933dd6407

    df.apply(min)

    ad8933dd6407

    df.apply(min, axis=1)

    ad8933dd6407

    #判断每个列,值是否都大于0

    df.apply(

    lambda x: numpy.all(x>0),

    axis=1

    )

    ad8933dd6407

    #结合过滤

    df[df.apply(

    lambda x: numpy.all(x>0),

    axis=1

    )]

    ad8933dd6407

    展开全文
  • python3 定义向量运算

    千次阅读 2018-05-30 11:04:00
    #定义向量的构造方法 class Vector: def __init__(self,x=0,y=0): self.x=x; self.y=y; ''' __repr__是python的内置方法,他能将一个对象用字符串的形式表达出来 %r用rper()方法处理对象 ...
  • python使用numpy向量运算注意点

    万次阅读 2017-06-23 22:17:29
    创建向量import numpy as np np.array([1,2])向量的维度一般我们看到的向量都是一行或者一列,在numpy中表示的向量都是一行,而且向量的转置还是它本身,啥都没变 向量的转置向量的逐乘和点乘
  • Python向量运算

    2019-07-02 15:19:46
    #生成等差数列 #一般的赋值需要通过for函数 r1_10=range(1,10,1) for i in r1_10: print(i) import numpy numpy.arange(2,10,3) r=numpy.arange(2,10,3) #向量运算 ...#向量运算,比较运算 r...
  • Vectorization深度学习算法中,数据量很大,在程序中尽量减少使用loop循环语句,而可以使用向量运算来提高程序运行速度。向量化(Vectorization)就是利用矩阵运算的思想,大大提高运算速度。例如下面所示在Python中...
  • python一维向量和二维向量运算

    千次阅读 2020-06-01 22:24:37
    一位向量a(n,)减去一位向量b(n,) 与 减去 c(n,1)的结果不同! a = np.array([1,2,3,4]) b = np.ones(4) c = b.reshape(-1,1) print(a-b) #[0. 1. 2. 3.] print(a-c) """ [[0. 1. 2. 3.] [0. 1. 2. 3.] [0. 1. 2....
  • import numpy as np a = np.array([1,2,3,4]) print(type(a)) print(a)
  • 本关任务: 编程实现两个列表向量相加。 相关知识 为了完成本关任务,你需要掌握:1. zip()函数, 2. 列表生成式 3.字符串转换为数值型列表/元组 zip()函数 a = [1,2,3] b = [4,5,6] c = list(zip(a,b)) #...
  • 1、关于python中矩阵点乘(除) 只允许三种情况出现: (1)两个矩阵维度相同,则对应元素相乘 (2)矩阵乘以一个向量: a: 矩阵与行向量 相乘(mxn * 1*n 形式), 此时行向量长度 必须等于矩阵的列数 b:矩阵与列...
  • 余弦相似度 import numpy as np def cos_sim(vector_a, vector_b): """ 计算两个向量之间的余弦相似度 :param vector_a: 向量 a :param vector_b: 向量 b :return: sim """ vector_a = np.mat(vector_a) vector_b =...
  • 提升python向量加法的运行速度   在使用python进行深度学习模型训练或预测时,我们经常会使用到向量加法运算。 我们这里比较两个向量相加的两种方法。 一、逐一做标量加法   这里首先定义两个...
  • Python脚本语言中如何实现三维向量的加减,点乘,叉乘的运算呢? 本例子将给大家介绍在类中调用函数的方法解决这个问题
  • python笔记5:向量运算

    千次阅读 2018-01-22 16:34:05
    #定义:向量化计算是一种特殊的并行计算的方式,它可以在同一时间执行多次操作,通常是对不同的数据执行同样的一个或一批指令,或者说把指令应用于一个数组/向量。 #1. 四则运算 #规则:相同位置的数据进行运算...
  • python数组运算

    千次阅读 2017-10-19 21:15:31
    本文摘自《用Python做科学计算》,版权归原作者所有。 1. NumPy-快速处理数据--ndarray对象--数组的创建和存取 2. NumPy-快速处理数据--ndarray对象--多维数组的存取、结构体数组存取、内存对齐、Numpy内存结构 ...
  • python向量化与循环耗时对比及其原理,向量化计算速度是循环的300倍。 1.测试 import time import numpy as np a = np.random.rand(1000000) b = np.random.rand(1000000) tic = time.time() c = np.dot(a,b) ...
  • Pythonic的Python向量夹角余弦值计算

    千次阅读 2020-09-20 19:29:36
    Pythonic的Python向量夹角余弦值计算 通过公式我们知道,cos⁡(x⃗,y⃗)=x⃗⋅y⃗∣x⃗∣×∣y⃗∣\cos{(\vec{x}, \vec{y})} = \frac{\vec{x}\cdot\vec{y}}{|\vec{x}|\times|\vec{y}|}cos(x,y​)=∣x∣×∣y​∣x⋅y...
  • python取模运算

    2012-03-05 10:57:20
    区分与其他语言,对于x%y,如果都是整数,则返回x/y的余数;如果是浮点数,返回的是x - int(x/y)*y ;如果是复数,返回的是x - int((x/y).real)*y。不过以上这些公式貌似都只是对于操作数都是整数的情况下才满足。...
  • python 矩阵运算

    万次阅读 2016-07-31 16:59:41
    科学计算:Python VS. MATLAB(3)----线性代数基础  按:在介绍工具之前先对理论基础进行必要的回顾是很必要的。没有理论的基础,讲再多的应用都是空中楼阁。本文主要设涉及线性代数和矩阵论的基本内容。先回顾这...
  • python矩阵运算

    千次阅读 2016-08-31 19:05:19
    Python使用NumPy包完成了对N-维数组的快速便捷操作。使用这个包,需要导入numpy。SciPy包以NumPy包为基础,大大的扩展了numpy的能力。为了使用的方便,scipy包在最外层名字空间中包括了所有的numpy内容,因此只要...
  • Python的Numpy库做向量运算

    千次阅读 2018-07-26 11:24:56
    Numpy的数据格式是ndarray,可以直接执行向量运算,比如: import numpy as np a = np.array([2, 4, 6]) print(a**2) array([ 4, 16, 36], dtype=int32) 但是,如果想直接对b = ['成景', '处理品', '府曹', '...
  • python矩阵的运算大全 python矩阵运算可以用numpy模块,也可以用scipy模块,主要运算包括以下几种: #1-1python矩阵运算所需模块 import numpy as npimport matplotlib.pyplot as pltimport scipy.linalg as lg #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,159
精华内容 13,263
关键字:

python向量运算

python 订阅