精华内容
下载资源
问答
  • 2020-08-26 11:39:44

    在函数功能库中添加功能 ==> Vector.py

        def norm(self):
            '返回向量的模'
            return math.sqrt(sum(e**2 for e in self))
    
        def dot(self,another):
            '向量点乘,返回结果标量'
            assert len(self) == len(another), \
                'Error in dot product. Length of vectors must be same'
            return sum(a * b for a, b in zip(self,another))
    
    	 def normalize(self):
    	        '返回向量的单位向量'
    	        if self.norm() < EPSILON:
    	            raise ZeroDivisionError('Normalize error! norm is zero.')
    	        return Vector(self._values) / self.norm()
    

    验证函数功能 ==> main_vector.py

    zero2 = Vector.zero(2)
        print(zero2)
        print('{} + {} = {}'.format(vec, zero2, vec + zero2))
    
        print('norm({}) = {}'.format(vec,vec.norm()))
        print('norm({}) = {}'.format(vec,vec2.norm()))
        print('norm({}) = {}'.format(vec,zero2.norm()))
    
        print('normalize {} is {}'.format(vec,vec.normalize()))
        print(vec.normalize().norm())
        print('normalize {} is {}'.format(vec2, vec2.normalize()))
        print(vec2.normalize().norm())
    
        try:
            zero2.normalize()
        except ZeroDivisionError:
            print('Cannot normalize zero vector {}'.format (zero2))
    
        print(vec.dot(vec2))
    
    # 输出结果为
    (0, 0)
    (5, 2) + (0, 0) = (5, 2)
    norm((5, 2)) = 5.385164807134504
    norm((5, 2)) = 3.1622776601683795
    norm((5, 2)) = 0.0
    normalize (5, 2) is (0.9284766908852593, 0.3713906763541037)
    1.0
    normalize (3, 1) is (0.9486832980505138, 0.31622776601683794)
    0.9999999999999999
    Cannot normalize zero vector (0, 0)
    17
    

    因为简单定义规范化函数,在计算机计算过程中,0不能为除数,所以在函数内部添加一个判断,如果参数的模为0的话,就返回 "Normalize error! norm is zero. "
    但是在进行去模运算时,计算结果大多数为浮点数,所以需要避免两个浮点数之间直接使用 == 这个方式去判断,而使用< 去定义一个精度。
    所以,在规范化函数中使用到了 EPSILON 去计算浮点误差所允许的精度范围。
    使用EPSILON就涉及到是否需要用全局函数。
    所以在 项目文件下 创建了一个 _global.py 文件去存放全局变量。
    EPSILON = 1e-8 ==> 1除以10的负八次方
    from ._global import EPSILON ==> 在函数库文件中 引用这个 全局变量文件

    更多相关内容
  • 1.3 Python向量化

    2021-10-09 19:39:15
    文章目录1.3.1 向量化(Vectorization)1.3.2 更多向量化的例子(More Vectorization Examples)1.3.3向量化logistic回归(Vectorizing Logistic Regression)1.3.4 向量化logistic回归的梯度输出(Vectorizing ...


    上一节我们主要介绍了逻辑回归, 以输出概率的形式来处理二分类问题。我们介绍了逻辑回归的Cost function表达式,并使用**梯度下降算法来计算最小化Cost function时对应的参数 w w w b b b 。**通过计算图的方式来讲述了神经网络的正向传播和反向传播两个过程。本节课我们将来探讨Python和向量化的相关知识。

    1.3.1 向量化(Vectorization)

    深度学习算法中,数据量很大,在程序中应该尽量减少使用loop循环语句,而可以使用向量运算来提高程序运行速度

    向量化(Vectorization)就是利用矩阵运算的思想,大大提高运算速度。例如下面所示在Python中使用向量化要比使用循环计算速度快得多。

    import numpy as np
    import time
    
    a = np.random.rand(1000000) # 生成一个[0,1)之间的随机N维浮点数组。
    b = np.random.rand(1000000)
    
    tic = time.time()
    c = np.dot(a, b) # 向量点乘
    toc = time.time()
    print(c)
    print("Vectorized version:" + str(1000 * (toc - tic)) + "ms")
    
    c = 0
    tic = time.time()
    for i in range(1000000):
        c += a[i] * b[i]
    toc = time.time()
    print(c)
    print("for loop:" + str(1000 * (toc - tic)) + "ms")
    

    输出结果类似于:

    250286.989866
    Vectorized version:1.5027523040771484ms
    250286.989866
    For loop:474.29513931274414ms
    

    从程序运行结果上来看,该例子使用for循环运行时间是使用向量运算运行时间的约 300 300 300 倍。因此,深度学习算法中,使用向量化矩阵运算的效率要高得多。

    为了加快深度学习神经网络运算速度,可以使用比CPU运算能力更强大的GPU。事实上,GPU和CPU都有并行指令(parallelization instructions),称为Single Instruction Multiple Data(SIMD)。SIMD单指令多数据流,能够复制多个操作数,并把它们打包在大型寄存器的一组指令集。SIMD能够大大提高程序运行速度,例如python的numpy库中的内建函数(built-in function)就是使用了SIMD指令。相比而言,GPU的SIMD要比CPU更强大一些

    1.3.2 更多向量化的例子(More Vectorization Examples)

    上一部分我们讲了应该尽量避免使用for循环而使用向量化矩阵运算。在python的numpy库中,我们通常使用np.dot()函数来进行矩阵运算。

    我们将向量化的思想使用在逻辑回归算法上,尽可能减少for循环,而只使用矩阵运算。值得注意的是,算法最顶层的迭代训练的for循环是不能替换的。而每次迭代过程对 J , d w , b J,dw,b J,dw,b 的计算是可以直接使用矩阵运算。

    1.3.3 向量化logistic回归(Vectorizing Logistic Regression)

    在1.2节介绍过,整个训练样本构成的输入矩阵 X X X 的维度是 ( n x , m ) (n_x,m) (nx,m) ,权重矩阵 w w w 的维度是 ( n x , m ) (n_x,m) (nx,m) b b b 是一个常数值,而整个训练样本构成的输出矩阵的 Y Y Y 维度为 ( 1 , m ) (1,m) (1,m) 。利用向量化的思想,所有 m m m 个样本的线性输出可 Z Z Z 以用矩阵表示:
    Z = w T X + b Z=w^TX+b Z=wTX+b
    在python的numpy库中可以表示为:

    Z = np.dot(w.T, X) + b
    A = sigmoid(Z)
    

    其中, w . T w.T w.T 表示 w w w 的转置。这样,我们就能够使用向量化矩阵运算代替for循环,对所有 m m m 个样本同时运算,大大提高了运算速度。

    1.3.4 向量化logistic回归的梯度输出(Vectorizing Logistic Regression’s Gradient Output)

    再来看逻辑回归中的梯度下降算法如何转化为向量化的矩阵形式。对于所有 m m m 个样本, d Z dZ dZ 的维度是 ( 1 , m ) (1,m) (1,m) ,可表示为:
    d Z = A − Y dZ=A-Y dZ=AY
    d b db db 可表示为:
    d b = 1 m ∑ i = 1 m d z ( i ) db=\frac{1}{m}\sum_{i=1}^{m}dz^{(i)} db=m1i=1mdz(i)
    对应的程序为:

    db = 1 / m * np.sum(dZ)
    

    d w dw dw 可表示为:
    d w = 1 m X ⋅ d Z T dw=\frac{1}{m}X\cdot dZ^T dw=m1XdZT
    对应的程序为:

    dw = 1 / m * np.dot(X, dZ.T)
    

    这样,我们把整个逻辑回归中的for循环尽可能用矩阵运算代替,对于单次迭代,梯度下降算法流程如下所示:

    Z = np.dot(w.T, X) + b
    A = sigmoid(Z)
    dZ = A - Y
    dw = 1 / m * np.dot(X, dZ.T)
    db = 1 / m * np.sum(dZ)
    
    w = w - alpha * dw
    b = b - alpha * db
    

    其中,alpha是学习因子,决定 w w w b b b 的更新速度。上述代码只是对单次训练更新而言的,外层还需要一个for循环,表示迭代次数。

    1.3.5 Python中的广播(Broadcasting in Python)

    下面介绍使用python的另一种技巧:广播(Broadcasting)。python中的广播机制可由下面四条表示:

    • 让所有输入数组都向其中shape最长的数组看齐,shape中不足的部分都通过在前面加 1 1 1 补齐;
    • 输出数组的shape是输入数组shape的各个轴上的最大值;
    • 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为 1 1 1 时,这个数组能够用来计算,否则出错;
    • 当输入数组的某个轴的长度为 1 1 1 时,沿着此轴运算时都用此轴上的第一组值。
    image-20211008144515358

    值得一提的是,在python程序中为了保证矩阵运算正确,可以使用reshape()函数来对矩阵设定所需的维度。这是一个很好且有用的习惯。

    1.3.6 关于python/numpy向量的说明(A note on python /numpy vectors)

    接下来我们将总结一些python的小技巧,避免不必要的code bug。

    python中,如果我们用下列语句来定义一个向量:

    a = np.random.randn(5) # [-0.43391831 -0.24814198  0.5111938  -0.89792554 -1.24439111]
    

    这条语句生成的 a a a 的维度是 ( 5 ,   ) (5,\space) (5, )。它既不是行向量也不是列向量,我们把 a a a 叫做rank 1 array。这种定义会带来一些问题。例如我们对 a a a 进行转置,还是会得到 a a a 本身。所以,如果我们要定义 ( 5 , 1 ) (5,1) (5,1) 的列向量或者 ( 1 , 5 ) (1,5) (1,5) 的行向量,最好使用下来标准语句,避免使用rank 1 array。

    a = np.random.randn(5,1) # [[-1.77381591][ 0.16036188] [ 0.71594668] [ 1.16073702] [ 0.23503555]]
    b = np.random.randn(1,5) # [[ 0.22552048  0.86586865 -1.37062805 -0.14825315 -2.07090315]]
    assert(a.shape == (5,1))
    a.reshape((5,1))
    

    除此之外,我们还可以使用assert语句对向量或数组的维度进行判断,assert会对内嵌语句进行判断,即判断 a a a 的维度是不是 ( 5 , 1 ) (5,1) (5,1) 的。如果不是,则程序在此处停止。使用assert语句也是一种很好的习惯,能够帮助我们及时检查、发现语句是否正确。

    另外,还可以使用reshape函数对数组设定所需的维度:

    1.3.7 Jupiter/iPython 笔记本的快速指南(Quick tour of Jupyter/iPython Notebooks)

    Jupyter notebook(又称IPython notebook)是一个交互式的笔记本,支持运行超过40种编程语言。本课程所有的编程练习题都将在Jupyter notebook上进行,使用的语言是python。

    1.3.8 (选修)logistic损失函数的解释(Explanation of logistic regression cost function(optional))

    在上一节课的笔记中,我们介绍过逻辑回归的Cost function。接下来我们将简要解释这个Cost function是怎么来的。

    首先,预测输出 y ^ \hat{y} y^ 的表达式可以写成:
    y ^ = σ ( w T x + b ) \hat{y}=\sigma\left(w^{T} x+b\right) y^=σ(wTx+b)
    其中, σ ( z ) = 1 1 + e − z \sigma(z)=\frac{1}{1+e^{-z}} σ(z)=1+ez1 y ^ \hat{y} y^ 可以看成是预测输出为正类( + 1 +1 +1)的概率:
    y ^ = P ( y = 1 ∣ x ) \hat{y}=P(y=1|x) y^=P(y=1x)
    那么,当 y = 1 y=1 y=1 时:
    P ( y ∣ x ) = y ^ P(y|x)=\hat{y} P(yx)=y^
    y = 0 y=0 y=0 时:
    P ( y ∣ x ) = 1 − y ^ P(y|x)=1-\hat{y} P(yx)=1y^
    我们把上面两个式子整合到一个式子中,得到:
    P ( y ∣ x ) = y ^ y ( 1 − y ^ ) ( 1 − y ) P(y|x)=\hat{y}^y(1-\hat{y})^{(1-y)} P(yx)=y^y(1y^)(1y)
    由于 log ⁡ \log log 函数的单调性,可以对上式 P ( y ∣ x ) P(y|x) P(yx) 进行 log ⁡ \log log 处理:
    log ⁡ P ( y ∣ x ) = log ⁡ y ^ y ( 1 − y ^ ) ( 1 − y ) = y log ⁡ y ^ + ( 1 − y ) log ⁡ ( 1 − y ^ ) \log P(y \mid x)=\log \hat{y}^{y}(1-\hat{y})^{(1-y)}=y \log \hat{y}+(1-y) \log (1-\hat{y}) logP(yx)=logy^y(1y^)(1y)=ylogy^+(1y)log(1y^)
    我们希望上述概率 P ( y ∣ x ) P(y|x) P(yx) 越大越好,对上式加上负号,则转化成了单个样本的Loss function,越小越好,也就得到了我们之前介绍的逻辑回归的Loss function形式。
    L = − ( t log ⁡ y ^ + ( 1 − y ) log ⁡ ( 1 − y ^ ) ) L=-(t\log \hat{y}+(1-y)\log (1-\hat{y})) L=(tlogy^+(1y)log(1y^))
    如果对于所有 m m m 个训练样本,假设样本之间是独立同分布的(iid),我们希望总的概率越大越好:
    max ⁡ ∏ i = 1 m P ( y ( i ) ∣ x ( i ) ) \max \prod_{i=1}^{m} P\left(y^{(i)} \mid x^{(i)}\right) maxi=1mP(y(i)x(i))
    同样引入 l o g log log 函数,加上负号,将上式转化为Cost function:
    J ( w , b ) = − 1 m ∑ i = 1 m L ( y ^ ( i ) , y ( i ) ) = − 1 m ∑ i = 1 m y ( i ) log ⁡ y ^ ( i ) + ( 1 − y ( i ) ) log ⁡ ( 1 − y ^ ( i ) ) J(w, b)=-\frac{1}{m} \sum_{i=1}^{m} L\left(\hat{y}^{(i)}, y^{(i)}\right)=-\frac{1}{m} \sum_{i=1}^{m} y^{(i)} \log \hat{y}^{(i)}+\left(1-y^{(i)}\right) \log \left(1-\hat{y}^{(i)}\right) J(w,b)=m1i=1mL(y^(i),y(i))=m1i=1my(i)logy^(i)+(1y(i))log(1y^(i))
    上式中, 1 m \frac{1}{m} m1 表示对所有 m m m 个样本的Cost function求平均,是缩放因子。

    1.3.9 总结(Summary)

    本节课我们主要介绍了神经网络基础——python和向量化。在深度学习程序中,使用向量化和矩阵运算的方法能够大大提高运行速度,节省时间。以逻辑回归为例,我们将其算法流程包括梯度下降转换为向量化的形式。同时,我们也介绍了python的相关编程方法和技巧。

    展开全文
  • # coding=utf-8 import math class Vector(object): ...根据坐标轴列表输入 创建向量, 并创建该向量所处的空间维度""" def __init__(self, coordinates): super(Vector, self).__init__()
     # coding=utf-8
    import math
    class Vector(object):
        """docstring for Vector"""
        """根据坐标轴列表输入 创建向量, 并创建该向量所处的空间维度"""
        def __init__(self, coordinates):
            super(Vector, self).__init__()
            try:
                if not coordinates:
                    raise ValueError
                self.coordinates = tuple(coordinates)
                self.dimension = len(coordinates)    
            except ValueError:
                raise ValueError('The coordinates must be nonempty')
            except TypeError:
                raise TypeError('The coordinates must be an iterable')
    
        # '''能够使python的内置print函数 输出向量坐标轴'''
    
        def __str__(self):
            return 'Vector: {}'.format(self.coordinates)
    
        def __eq__(self, v):
             return self.coordinates == v.coordinates
        
        # 计算向量长度
        def calculateSize(self):
            result = 0
            num = len(self.coordinates)
            for i  in range(num):
                result +=self.coordinates[i] * self.coordinates[i]
            result = math.sqrt(result)
            return round(result,3)
    
        # 将向量归一化
        def standardizaiton(self):
            size = self.calculateSize()
            new_corrdinate = [round(x/size,3) for x in self.coordinates]
            return Vector(new_corrdinate)
    
    myVector = Vector([-0.221,7.437])
    myVector2 = Vector([5.581,-2.136])
    myVector3 = Vector([8.813,-1.331,-6.247])
    myVector4 = Vector([1.996,3.108,-4.554])
    
    
    
    
    print myVector.calculateSize()
    print myVector2.standardizaiton()
    print myVector3.calculateSize()
    print myVector4.standardizaiton()
    # 输出结果
    # 7.44
    # Vector: (0.934, -0.357)
    # 10.884
    # Vector: (0.34, 0.53, -0.777)
    # [Finished in 0.1s]
    

    优化

       
        # 计算向量长度
        def magnitude(self):
            coordinates_squared = [x**2 for x in self.coordinates]
            return math.sqrt(sum(coordinates_squared))
    
        # 将向量归一化
        def normalized(self):
            try:
                magnitude = self.magnitude()
                return [x *(1./magnitude) for x in self.coordinates]
            except ZeroDivisionError:
                raise Exception('Cannot normalized the zero myVector2')
           
    
    myVector = Vector([-0.221,7.437])
    myVector2 = Vector([5.581,-2.136])
    myVector3 = Vector([0,0])
    
    print myVector.magnitude()
    print myVector2.normalized()
    print myVector3.normalized()
    
    # 输出
    # 7.44028292473
    # [0.9339352140866403, -0.35744232526233]
    # Traceback (most recent call last):
    #   File "/Users/Scarlett/Desktop/MovieProject/Vector.py", line 47, in <module>
    #     print myVector3.normalized()
    #   File "/Users/Scarlett/Desktop/MovieProject/Vector.py", line 38, in normalized
    #     raise Exception('Cannot normalized the zero myVector2')
    # Exception: Cannot normalized the zero myVector2
    # [Finished in 0.1s with exit code 1]
    展开全文
  • 如下所示: import numpy as np Z=np.random.random((5,... 您可能感兴趣的文章:详解python实现数据归一处理的方式:(0,1)标准化Python数据预处理之数据规范(归一)示例python 实现对数据集的归一的方法(0-
  • 这篇文章主要介绍了如何基于python实现归一处理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下  一、定义  归一方法有两种形式,一种是把数变为(0,1)...
  • 好久没有写文章了,抱歉了,以后每天...两个向量“相乘”:等于两个向量的模(长度)乘于夹角的余弦在二维空间中,向量的点乘:使用余弦定理证明:向量点乘的直观理解:向量的点乘,两个向量必须是同方向的,所以做...

    好久没有写文章了,抱歉了,以后每天都会更新一篇的....

    向量的点乘,也就是两个向量相乘:

    我们是不这么定义的,不是两个向量对应的坐标元素相乘:

    两个向量“相乘”,结果是⼀个数!,两个向量"相乘",更严格的说法:两个向量的点乘,两个向量的内积。

    两个向量“相乘”:等于两个向量的模(长度)乘于夹角的余弦

    在二维空间中,向量的点乘:

    使用余弦定理证明:

    向量点乘的直观理解:

    向量的点乘,两个向量必须是同方向的,所以做投影以后的长度再相乘

    同样,可以用坐标来理解:

    v向量分解为x轴的x2向量,y轴的y2向量,u向量分解为x轴的x1向量,和y轴的y1向量,然后分别相乘,有4种情况,垂直的向量相乘为0,所以是x1.x2+y1.y2

    使用Python实现向量的点乘:

    具体代码:

    定义一个内部使用的文件_globals,用来存储全局使用的变量 EPSILON,用来判断精度用的

    EPSILON = 1e-8

    Vector的代码:

    import math

    from ._globals import EPSILON

    class Vector:

    def __init__(self, lst):

    self._values = list(lst)

    @classmethod

    def zero(cls, dim):

    """返回一个dim维的零向量"""

    return cls([0] * dim)

    def __add__(self, another):

    """向量加法,返回结果向量"""

    assert len(self) == len(another), \

    "Error in adding. Length of vectors must be same."

    return Vector([a + b for a, b in zip(self, another)])

    def __sub__(self, another):

    """向量减法,返回结果向量"""

    assert len(self) == len(another), \

    "Error in subtracting. Length of vectors must be same."

    return Vector([a - b for a, b in zip(self, another)])

    def norm(self):

    """返回向量的模"""

    return math.sqrt(sum(e**2 for e in self))

    def normalize(self):

    """返回向量的单位向量"""

    if self.norm() < EPSILON:

    raise ZeroDivisionError("Normalize error! norm is zero.")

    return Vector(self._values) / self.norm()

    def dot(self, another):

    """向量点乘,返回结果标量"""

    assert len(self) == len(another), \

    "Error in dot product. Length of vectors must be same."

    return sum(a * b for a, b in zip(self, another))

    def __mul__(self, k):

    """返回数量乘法的结果向量:self * k"""

    return Vector([k * e for e in self])

    def __rmul__(self, k):

    """返回数量乘法的结果向量:k * self"""

    return self * k

    def __truediv__(self, k):

    """返回数量除法的结果向量:self / k"""

    return (1 / k) * self

    def __pos__(self):

    """返回向量取正的结果向量"""

    return 1 * self

    def __neg__(self):

    """返回向量取负的结果向量"""

    return -1 * self

    def __iter__(self):

    """返回向量的迭代器"""

    return self._values.__iter__()

    def __getitem__(self, index):

    """取向量的第index个元素"""

    return self._values[index]

    def __len__(self):

    """返回向量长度(有多少个元素)"""

    return len(self._values)

    def __repr__(self):

    return "Vector({})".format(self._values)

    def __str__(self):

    return "({})".format(", ".join(str(e) for e in self._values))

    测试代码:

    from playLA.Vector import Vector

    if __name__ == "__main__":

    vec = Vector([5, 2])

    print(vec)

    print("len(vec) = {}".format(len(vec)))

    print("vec[0] = {}, vec[1] = {}".format(vec[0], vec[1]))

    vec2 = Vector([3, 1])

    print("{} + {} = {}".format(vec, vec2, vec + vec2))

    print("{} - {} = {}".format(vec, vec2, vec - vec2))

    print("{} * {} = {}".format(vec, 3, vec * 3))

    print("{} * {} = {}".format(3, vec, 3 * vec))

    print("+{} = {}".format(vec, +vec))

    print("-{} = {}".format(vec, -vec))

    zero2 = Vector.zero(2)

    print(zero2)

    print("{} + {} = {}".format(vec, zero2, vec + zero2))

    print("norm({}) = {}".format(vec, vec.norm()))

    print("norm({}) = {}".format(vec2, vec2.norm()))

    print("norm({}) = {}".format(zero2, zero2.norm()))

    print("normalize {} is {}".format(vec, vec.normalize()))

    print(vec.normalize().norm())

    print("normalize {} is {}".format(vec2, vec2.normalize()))

    print(vec2.normalize().norm())

    try:

    zero2.normalize()

    except ZeroDivisionError:

    print("Cannot normalize zero vector {}.".format(zero2))

    print(vec.dot(vec2))

    注意:

    向量的点乘的应⽤

    1、求出两个向量之间的夹角范围,或者具体值

    2、判断两个向量的相似程度(推荐系统)

    一组物品进行推荐,可能是电影,音乐....在推荐的时候,最典型的推荐策略就是推荐和你的喜好最相似的内容,比如说,你已经在系统上留下足迹,喜欢电影A,此时电影B和A相似,推荐系统就会倾向把电影B推荐给你,电影C和电影B极其不相似,推荐系统就不会推荐。

    在这个背后如何判断两个电影是否相似?

    很简单的判断就是使用向量的点乘,在这种情况下,可以想象一下,每一个电影都可以理解为一个高维空间中的点,把向量另外一种视角看待(高维空间中的一个点),对电影来说,它可能有(电影的时间,演员的列表,电影的导演,电影的类型,电影的色调,台词量....)的一个高维度信息,就是在一个高维空间中的点,在这种情况下,如果我们转换我们的视角,把每个电影又转换成一个高维空间中的一个向量,每两个电影之间就会存在一个夹角,这时候,我们可以看这两个电影之间的夹角是直角,钝角,还是锐角,,如果是锐角,那么这两个电影之间有一部分是重合的,我就说这两个电影是相似的,如果是垂直的,那么这两部电影就是无关的,如果是顿角那么这两部电影是背离的。

    在这里我们不仅可以看两个向量之间的夹角,还可以看点乘的结果(值),如果点乘的值为正值,并且越大,说明这两个电影越相似,在最极端的情况下,这两个向量完全重合的时候,那么这时候这两个向量的点乘将达到最大值,也就是两个电影的高维空间中的点(电影的时间,演员的列表,电影的导演,电影的类型,电影的色调,台词量....)已经重合了。

    换句话说,我们可以使用向量点乘的方式,来看两个向量(电影)的相似,值越大,越相似,值越小,越不一样,这就是向量的点乘在推荐系统中的一个典型应用,当然了,现在的推荐

    系统都比较复杂,在判断两个物品是否相似的时候,也有其他更加准确的方法,不仅如此,在具体判断两个物品是否相似之前,对两个物品所对应的数据也也需要进行很多的处理。

    3、⼏何计算

    v向量投影到u向量上

    投影点的方向,也就是u向量除以u向量的模,也就是u向量方向的单位向量,举例子,u向量为(3,4),模长为5,u向量方向的单位向量为(3/5,4/5)

    展开全文
  • matlab-线性代数 向量单位化

    千次阅读 2019-02-21 23:03:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 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 = ['成景', '处理品', '府曹', '...
  • 2、词向量-->单位向量 2.1、原理 2.2、极简代码 3、词向量+TFIDF 3.1、原理 3.2、极简代码 3.3、引入TFIDF前后可视对比 4、降维 4.1、降到二维并可视 4.2、降到三维并可视 对训练后的词向量,引入预设词性特征...
  • 它可以形象地表示为带箭头的线段。箭头所指:代表向量的方向;线段长度:代表向量的大小。与向量对应的只有大小,没有方向的量叫做数量(物理学中称标量)在这里,向量即一维数组,用 arange 函数创建向量是最简单...
  • Python实现向量自回归(VAR)模型——完整步骤

    万次阅读 多人点赞 2019-02-01 15:20:14
    博主真是苦逼,最近定期要写研报,博主挑了个向量自回归模型(VAR)来研究,然而博主之前接触过的就只有MATLAB和python,matlab虽然做这种统计很方便,但是一个是博主好久不用啦有点生疏,还有一个是跟项目开发合在...
  • python vtk 法向量计算
  • python 归一方法

    千次阅读 2021-10-20 17:18:17
    1、min-max标准(Min-Max Normalization) from sklearn import preprocessing import numpy as np X = np.array([[ 1., -1., 2.], [ 2., 0., 0.], [ 0., 1., -1.]]) min_max_scaler = preprocessing....
  • 问题描述: 想对向量归一, 或者说 让向量除以模长 解决方法, 看示例 import torch import torch.nn.functional as F a = torch.arange(9, dtype= torch.float) a = a.reshape((3,3)) print(a) ''' tensor(...
  • 7.1 文本向量化概述  文本表示是自然语言处理中的基础工作,文本表示的好坏直接影响到整个自然语言处理系统的性能。文本向量化是文本表示的一种重要方式。顾名思义,文本向量化就是将文本表示成一系列能够表达文本...
  • 原理数据正规(data normalization)是将数据的每个样本(向量)变换为单位范数的向量,各样本之间是相互独立的.其实际上,是对向量中的每个分量值除以正规因子.常用的正规因子有 L1, L2 和 Max.假设,对长度为...
  • 线性代数中单位向量的定义Linear algebra is the branch of mathematics concerning linear equations by using vector spaces and through matrices. In other words, a vector is a matrix in n-dimensional space...
  • 支持线性代数您提到要支持线性代数,例如向量加法(元素加法)、叉积和内积。这些可用于numpy.ndarray,因此您可以选择不同的方法来支持它们:只需使用一个numpy.ndarray,而不必为自己的类操心:import numpy as ...
  • 一、生成单位阵 numpy.identity(N) 和 numpy.eye(N) 都可以用来产生单位阵,且产生的单位阵都是 np.array() 类型,矩阵元素都是 float 型。...(参考:python生成单位阵或者对角阵的三种方法) 三、矩...
  • python归一处理

    2020-12-05 09:45:28
    二、目的不同评价指标往往具有不同的量纲和量纲单位,这样的情况会影响到数据分析的结果,为了消除指标之间的量纲影响,需要进行数据标准处理,以解决数据指标之间的可比性。其具体针对的是奇异样本数据,奇异样本...
  • [Python] 使用 Pandas 向量化处理时间戳

    千次阅读 2020-03-25 15:44:55
    字符串日期 >> 时间戳 (批量) 当要处理的日期数据有很多行时, 用apply或者map函数逐个转换的方法会很慢, 这时需要利用 Pandas 的向量化操作来处理 dates = pd.Series(pd.date_range('20200101', '20201231')) ...
  • 数据聚焦于数据的采集、清理、预处理、分析和挖掘,图形聚焦于解决对光学图像进行接收、提取信息、加工变换、模式识别及存储显示,可视聚焦于解决将数据转换成图形,并进行交互处理。 信息:是数据的内涵,信息是...
  • 基于the last approach on this page,您可以简单地生成由三个标准正态分布的独立样本组成的向量,然后对向量进行归一,使其大小为1:import numpy as npdef sample_spherical(npoints, ndim=3):vec = np.random....
  • python平方符号

    千次阅读 2020-12-02 16:02:26
    广告关闭提供包括云服务器,云数据库在内的50+款云计算产品。打造一站式的云产品试用服务,助力开发者和企业零门槛上云。翻译:老齐与本文相关图书推荐:《跟老齐学python:数据分析... 索引 这个符号用于表示向量中...
  • 本文描述了训练支持向量回归模型的过程,该模型用于预测基于几个天气变量、一天中的某个小时、以及这一天是周末/假日/在家工作日还是普通工作日的用电量。 关于支持向量机的快速说明 支持向量机是机器学习的一种...
  • python中生成随机数组/向量

    万次阅读 2018-11-13 13:30:06
    使用numpy.random模块来生成随机数组转载 1、np.random.rand 用于生成[0.0, 1.0)之间的随机浮点数, 当没有参数时,返回一个随机...2、np.random.randn(10)该函数返回一个10维向量,具有标准正态分布 3、np.ran...
  • 数据归一:数据的标准是将数据按比例缩放,使之落入一个小的特定区间,去除数据的单位限制,将其转化为无量纲的纯数值,便于不同单位或量级的指标能够进行比较和加权。为什么要做归一:1)加快梯度下降求最优解...
  • python之pygame运动及向量(四)

    千次阅读 2019-08-09 16:26:02
    #向量规格 vector_to_mouse . normalise ( ) #heading可看作兔子的速度,在没有到鼠标时加速,超过则减速 #则可看作兔子在胡萝卜旁边晃动 heading = heading + ( vector_to_mouse * .6 ) ...
  • HOG HOG 特征, histogram of oriented gradient, 梯度方向直方图特征, 作为提取基于梯度的特征, HOG 采用了统计的方式(直方图)进行提取. 其基本思路是将图像...2.Block作为基本的特征提取单位, 在其内部再次进行细分

空空如也

空空如也

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

python向量单位化

友情链接: TongaBiosReader-master.zip