精华内容
下载资源
问答
  • Python计算余弦相似度

    千次阅读 多人点赞 2020-08-09 10:51:39
    余弦相似度常用在文本分类、图片分类等应用中,来计算两个文本或两个图像之间的相似度。 本文主要介绍通过Python计算两个向量的余弦相似度

    余弦相似度常用在文本分类、图片分类等应用中,来计算两个文本或两个图像之间的相似度。

    如下图,向量 a = [ x 1 , y 1 ] , b = [ x 2 , y 2 ] \boldsymbol a=[x_1,y_1],\boldsymbol b =[x_2,y_2] a=[x1,y1],b=[x2,y2]
    在这里插入图片描述 s i m ( a , b ) = c o s θ = a b ∣ a ∣ ∣ b ∣ = x 1 x 2 + y 1 y 2 x 1 2 + y 1 2 x 2 2 + y 2 2 sim(a,b) = cos \theta = \frac {ab}{\mid a \mid \mid b \mid} = \frac {x_1x_2+y_1y_2}{\sqrt{x_1^2+y_1^2}\sqrt{x_2^2+y_2^2}} sim(a,b)=cosθ=abab=x12+y12 x22+y22 x1x2+y1y2对于 n n n维向量 A = [ a 1 , a 2 , . . . a n ] , B = [ b 1 , b 2 , . . . b n ] A=[a_1,a_2,...a_n],B=[b_1,b_2,...b_n] A=[a1,a2,...an],B=[b1,b2,...bn]
    s i m ( A , B ) = A B ∣ A ∣ ∣ B ∣ = ∑ i = 1 n A i B i ∑ i = 1 n A i 2 ∑ i = 1 n A i 2 sim(A,B) = \frac {AB}{\mid A \mid \mid B \mid}= \frac {\sum_{i=1}^{n}{A_iB_i}}{\sqrt{\sum_{i=1}^{n}{A_i^2}}\sqrt{\sum_{i=1}^{n}{A_i^2}}} sim(A,B)=ABAB=i=1nAi2 i=1nAi2 i=1nAiBi

    余弦相似度的取值范围在-1到1之间。余弦值越接近1,也就是两个向量越相似,完全相同时数值为1;相反反向时为-1;正交或不相关是为0。

    求余弦相似度需要用到np.linalg.norm 操作,来求向量的范式,默认是L2范式,等同于求向量的欧式距离。

    import numpy as np
    t1  = np.array([-0.4,0.8,0.5,-0.2,0.3])
    t2  = np.array([-0.5,0.4,-0.2,0.7,-0.1])
    
    def cos_sim(a, b):
        a_norm = np.linalg.norm(a)
        b_norm = np.linalg.norm(b)
        cos = np.dot(a,b)/(a_norm * b_norm)
        return cos
    print(cos_sim(t1,t2))
    

    输出:0.23612240736068565

    展开全文
  • python计算余弦相似度

    2020-12-21 10:27:51
    余弦相似度常用在文本分类、图片分类等应用中,来计算两个文本或两个图像之间的相似度。 余弦相似度的取值范围在-1到1之间。余弦值越接近1,也就是两个向量越相似,完全相同时数值为1;相反反向时为-1;正交或不...

    余弦相似度常用在文本分类、图片分类等应用中,来计算两个文本或两个图像之间的相似度。

    在这里插入图片描述
    在这里插入图片描述

    余弦相似度的取值范围在-1到1之间。余弦值越接近1,也就是两个向量越相似,完全相同时数值为1;相反反向时为-1;正交或不相关是为0。

    求余弦相似度需要用到np.linalg.norm 操作,来求向量的范式,默认是L2范式,等同于求向量的欧式距离。

    import numpy as np
    t1  = np.array([-0.4,0.8,0.5,-0.2,0.3])
    t2  = np.array([-0.5,0.4,-0.2,0.7,-0.1])
    
    def cos_sim(a, b):
        a_norm = np.linalg.norm(a)
        b_norm = np.linalg.norm(b)
        cos = np.dot(a,b)/(a_norm * b_norm)
        return cos
    print(cos_sim(t1,t2))
    
    

    转载来源

    展开全文
  • Python计算余弦相似度的方法及时间比较 形如有一个矩阵ashape形如(4,99999)和bshape形如(32,99999),a的每一行去和b的每一行做余弦相似度计算,output一个shape形如(4,32)的余弦相似度矩阵。 a = np.random....

    Python计算余弦相似度的方法及时间比较

    形如有一个矩阵ashape形如(4,99999)和bshape形如(32,99999),a的每一行去和b的每一行做余弦相似度计算,output一个shape形如(4,32)的余弦相似度矩阵。

    a = np.random.random(size = (4,99999)).tolist()
    b = np.random.random(size = (32,99999)).tolist()
    

    1. Scipy

    from scipy import spatial
    t1 = time.time()
    cos_mat_sci = list(map(lambda x:list(map(lambda y:1-spatial.distance.cosine(x,y), b)),a))
    t2 = time.time()
    print('scipy time cost',t2-t1,'s')
    #time cost 1.325453519821167 s
    

    2. Sklearn

    time_start=time.time()
    cos_mat_sk = list(map(lambda x:list(map(lambda y:cosine_similarity([x,y])[0][1], b)),a))
    time_end=time.time()
    print('sklearn time cost',time_end-time_start,'s') 
    #time cost 1.7672739028930664 s
    

    3. Numpy手撸

    def cos_sim(a, b):
        a_norm = np.linalg.norm(a)
        b_norm = np.linalg.norm(b)
        cos = np.dot(a,b)/(a_norm * b_norm)
        return cos
    
    time_start=time.time()
    cos_mat_np = list(map(lambda x:list(map(lambda y:cos_sim(x,y), b)),a))
    time_end=time.time()
    print('numpy time cost',time_end-time_start,'s') 
    #time cost 3.1022114753723145 s
    

    4. torch

    import torch
    import torch.nn.functional as F
    a_tf = torch.FloatTensor(a)
    b_tf = torch.FloatTensor(b)
    time_start=time.time()
    cos_mat_torch = list(map(lambda x:list(map(lambda y:F.cosine_similarity(x,y, dim=0), b_tf)),a_tf))
    time_end=time.time()
    print('torch time cost',time_end-time_start,'s') 
    # time cost 0.028922557830810547 s
    

    输出结果

    scipy time cost 1.325453519821167 s
    sklearn time cost 1.7672739028930664 s
    numpy time cost 3.1022114753723145 s
    torch time cost 0.028922557830810547 s
    >>> cos_mat_sci[0][:3]
    [0.7521347867015734, 0.7507867569813598, 0.7505274811256897]
    >>> cos_mat_sk[0][:3]
    [0.7521347867015696, 0.7507867569813551, 0.7505274811256867]
    >>> cos_mat_np[0][:3]
    [0.7521347867015734, 0.7507867569813594, 0.7505274811256898]
    >>> cos_mat_torch[0][:3]
    [tensor(0.7521), tensor(0.7508), tensor(0.7505)]
    

    综合而言,torch用时最短,但在默认情况下其内部计算精度较低;综合而言scipy在相对要求精度的前提下是比较优秀的。np.linalg根据定义计算相对是最耗时的。

    展开全文
  • Python计算余弦相似度及向量范数

    千次阅读 2020-09-08 11:18:58
    1、Python余弦相似度 计算两个句子向量 2、np.linalg.norm求 向量模长(一范二范) 3、python列表转换为矩阵 1、Python余弦相似度 在非直角三角形中,余弦定理的公式是: 在向量表示的三角形中,假设a向量是...

    目录

    1、Python求余弦相似度

    计算两个句子向量

    2、np.linalg.norm 求 向量模长(一范二范)

    3、python列表转换为矩阵


    1、Python求余弦相似度

    在非直角三角形中,余弦定理的公式是:

     

    在向量表示的三角形中,假设a向量是(x1, y1),b向量是(x2, y2),那么可以将余弦定理改写成下面的形式:

    扩展,如果向量a和b不是二维而是n维,上述余弦的计算法仍然正确。假定a和b是两个n维向量,则a与b的夹角 的余弦等于:

    计算两个句子向量

    句子A:(1,1,2,1,1,1,0,0,0)

    和句子B:(1,1,1,0,1,1,1,1,1)的向量余弦值来确定两个句子的相似度。

    根据:

    计算过程及(通用)代码如下:

    1、调用sklearn 

    from sklearn.metrics.pairwise import cosine_similarity
     
    a = [[1, 3, 2], [2, 2, 1]]
    print(cosine_similarity(a))

    2、方法1,常规算法,计算较慢

    def cos_sim(s1_cut_code, s2_cut_code):
        # 计算余弦相似度
        sum = 0
        sq1 = 0
        sq2 = 0
        for i in range(len(s1_cut_code)):
            sum += s1_cut_code[i] * s2_cut_code[i]
            sq1 += pow(s1_cut_code[i], 2)
            sq2 += pow(s2_cut_code[i], 2)
    
        try:
            result = round(float(sum) / (math.sqrt(sq1) * math.sqrt(sq2)), 3)
        except ZeroDivisionError:
            result = 0.0
    #     print("余弦相似度为:%f"%result)
        return result

     方法2 计算较快

    def norm(vector):
        return math.sqrt(sum(x * x for x in vector))    
    
    def cosine_similarity(vec_a, vec_b):
        norm_a = norm(vec_a)
        norm_b = norm(vec_b)
        dot = sum(a * b for a, b in zip(vec_a, vec_b))
        return dot / (norm_a * norm_b)

    3、稀疏矩阵

    def computer_simMatrix(c):
        """
       稀疏矩阵求相似度
        """
        return c.dot(c.T)/sparse.linalg.norm(c,axis=1).reshape((-1,1)).dot(sparse.linalg.norm(c,axis=1).reshape((1,-1)))
    
    # 返回一个矩阵,上三角和下三角是对称的,维度=len(c[0])*len(c[0])

    2、np.linalg.norm 求 向量模长(一范二范)

    x_norm=np.linalg.norm(x, ord=None, axis=None, keepdims=False)

    ①x: 表示矩阵(也可以是一维)

    ②ord:范数类型

    向量的范数:

     

    矩阵的范数:

    ord=1:列和的最大值

    ord=2:|λE-ATA|=0,求特征值,然后求最大特征值得算术平方根

    ord=∞:行和的最大值

    ③axis:处理类型

    axis=1表示按行向量处理,求多个行向量的范数

    axis=0表示按列向量处理,求多个列向量的范数

    axis=None表示矩阵范数。

    ④keepding:是否保持矩阵的二维特性

    True表示保持矩阵的二维特性,False相反


    # 求向量的三种范式,代码如下:

    A = np.array([[3,4],[-6,5]])
    
    ret = np.linalg.norm(A,ord=None) # 对象是矩阵,求矩阵元素平方和开放
    print(ret)
    
    ret = np.linalg.norm(A,ord=None,axis=1) # 对象是逐行,求每行元素平方和开放
    print(ret)
    
    ret = np.linalg.norm(A,ord=None,axis=0)  # 对象是逐列,求每列元素平方和开放
    print(ret)
    # 对象是矩阵,求矩阵中逐行元素绝对值和的最大值
    ret = np.linalg.norm(A,ord=np.Inf)
    print(ret)
    
    ret = np.linalg.norm(A,ord=np.Inf,axis=1) # 对象是逐行,求每行元素绝对值和的最大值
    print(ret)
    
    ret = np.linalg.norm(A,ord=np.Inf,axis=0) # 对象是逐列,求每列元素绝对值的最大值
    print(ret)
    
    
    # 对象是矩阵,求矩阵中逐行元素绝对值和的最小值
    ret = np.linalg.norm(A,ord=-np.Inf)  
    print(ret)
    
    ret = np.linalg.norm(A,ord=-np.Inf,axis=1) # 对象是逐行,求行的元素绝对值的最小值
    print(ret)
    
    ret = np.linalg.norm(A,ord=-np.Inf,axis=0) # 对象是逐列,求列的元素绝对值的最小值
    print(ret)
    A = np.array([[3,-4,1],[-6,5,0]])
    
    ret = np.linalg.norm(A,ord=0,axis=1) # 对象是逐行,求每行的非零元素个数
    print(ret)
    
    ret = np.linalg.norm(A,ord=0,axis=0) # 对象是逐列,求每列的非零元素个数
    print(ret)
    A = np.array([[100,4],[-6,5]])
    ret = np.linalg.norm(A,ord=1)   # 对象是矩阵,求列的元素绝对值和的最大值
    print(ret)
    
    ret = np.linalg.norm(A,ord=1,axis=1)  # 对象是逐行,求行的元素绝对值和
    print(ret)
    
    ret = np.linalg.norm(A,ord=1,axis=0)    # 对象是逐列,求;列的元素绝对值和
    print(ret)
    A = np.array([[-4,3,1],[-6,5,-1]])
    ret = np.linalg.norm(A,ord=-1)  # 对象是矩阵,求列的元素绝对值和最小值
    print(ret)
    ret = np.linalg.norm(A,ord=-1,axis=1) # 对象是逐行
    print(ret)
    ret = np.linalg.norm(A,ord=-1,axis=0)  # 对象是逐列
    print(ret)
    A = np.array([[-4,  3, 4],
                      [-6,  4, 3]])
    #10.0015300174, 对象是矩阵,求所有元素平方和开方,所有元素平方和102,开方=10.0015300174
    ret = np.linalg.norm(A, ord=2)
    #[ 6.40312424  7.81024968],对象是每行,求行的元素平方和开方
    ret = np.linalg.norm(A, ord=2, axis=1)
    #[ 7.21110255  5. 5.],对象是每列,求列的元素平方和开方
    ret = np.linalg.norm(A, ord=2, axis=0)

    3、python列表转换为矩阵

    #创建列表
    >>> l=[] //然后用列表的insert函数将系数项插入到列表中去,最后将列表转换为矩阵
    insert(“插入位置”,插入的内容对象)
    >>> l.insert(0,[9,52,381])
    >>> l
    [[9, 52, 381]]
    >>> l.insert(1,[52,381,3017])
    >>> l
    [[9, 52, 381], [52, 381, 3017]]
    >>> l.insert(2,[381,3017,25317])
    >>> l
    [[9, 52, 381], [52, 381, 3017], [381, 3017, 25317]]
    >>> a=np.mat(l)#这里将列表转换为矩阵
    >>> a
    matrix([[ 9, 52, 381],
    [ 52, 381, 3017],
    [ 381, 3017, 25317]])
    
    >>> l=[]
    >>> l.insert(0,[32])
    >>> l.insert(1,[147])
    >>> l.insert(2,[1025])
    >>> l
    [[32], [147], [1025]]
    >>> b=np.mat(l)#将列表转换为矩阵
    >>> b
    matrix([[ 32],
    [ 147],
    [1025]])


    scipy.sparse的一些整理 https://blog.csdn.net/qq_33466771/article/details/80304498

    Scipy教程 - 线性代数库scipy.linalg http://blog.csdn.net/pipisorry/article/details/43277755

    相似度算法之余弦相似度 https://blog.csdn.net/zz_dd_yy/article/details/51926305

    python求向量的三种范式 https://blog.csdn.net/wangdong2017/article/details/81297654

    展开全文
  • Say the input matrix is: A= [0 1 0 0 1 0 0 1 1 1 1 1 0 1 0] The sparse representation is: A = 0, 1 0, 4 1, 2 1, 3 1, 4 2, 0 2, 1 2, 3 In Python, it's straightforward to work with the matrix-input ...
  • 余弦相似度 pythonWhat is cosine similarity?什么是余弦相似度? Cosine similarity measures the similarity between two vectors by calculating the cosine of the angle between the two vectors. 余弦相似度...
  • 余弦相似度,又称为余弦相似性,是通过计算两个向量的夹角余弦值来评估他们的相似度。对于两个向量,可以想象成空间中的两条线段,都是从原点([0, 0, ...])出发,指向不同的方向。两条线段之间形成一个夹角:如果...
  • reference:... # -*- coding:utf-8 -*- # 余弦计算相似度度量 http://blog.csdn.net/u012160689/article/details/15341303 import math import re import datetim...
  • python基于余弦相似度Cosine Similarity的检索系统 下面是源码,不足之处请提出并指正: import jieba x = input("输入关键词:") #输入关键词 seg_list1 = jieba.cut(x, cut_all=True) a = "/".join(seg_list1) a...
  • 背景在计算相似度时,常常用到余弦夹角来判断相似度,Cosine(余弦相似度)取值范围[-1,1],当两个向量的方向重合时夹角余弦取最大值1,当两个向量的方向完全相反夹角余弦取最小值-1,两个方向正交时夹角余弦取值为0...
  • I need to compare documents stored in a DB and come up with a similarity score between 0 and 1.The method I need to use has to be very simple. Implementing a vanilla version of n-grams (where it possi...
  • python-余弦相似度

    2020-05-11 16:08:09
    余弦相似度相关系数 import jieba import math import numpy as np #——————————————————————————创建样本与分词————————————————————————————————...
  • python 向量余弦相似度

    2021-05-15 22:42:29
    similarity 出来是对称矩阵,只需要取[0][1]就ok了 print("1111",time.time() - start, cosine_similarity([[1,2,3,4],[1,2,2,3]])[0][1]) 方法3 def cos_sim(vector_a, vector_b): """ 计算两个向量之间的余弦相似度 ...
  • 余弦相似度计算: 有了上面的基础知识,我们可以将每个分好词和去停用词的文档进行文档向量化,并计算出每一个词项的权重,而且每个文档的向量的维度都是一样的,我们比较两篇文档的相似性就可以通过计算这两个...
  • Python 使用sklearn计算余弦相似度

    千次阅读 2020-09-13 17:36:21
    计算相似度时,常常用到余弦夹角来判断相似度,Cosine(余弦相似度)取值范围[-1,1],当两个向量的方向重合时夹角余弦取最大值1,当两个向量的方向完全相反夹角余弦取最小值-1,两个方向正交时夹角余弦取值为0。...
  • Python计算文本余弦相似度

    千次阅读 2020-06-27 12:24:31
    /usr/bin/python3 import kashgari from kashgari.embeddings import BERTEmbedding import logging import numpy as np from sklearn.metrics.pairwise import cosine_similarity import jieba import sys chinese...
  • 今天小编就为大家分享一篇Python 余弦相似度与皮尔逊相关系数 计算实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • python实现余弦相似度文本比较

    千次阅读 2018-06-21 15:01:00
    余弦相似度计算:  有了上面的基础知识,我们可以将每个分好词和去停用词的文档进行文档向量化,并计算出每一个词项的权重,而且每个文档的向量的维度都是一样的,我们比较两篇文档的相似性就可以通过计算这两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,158
精华内容 2,063
关键字:

python计算余弦相似度

python 订阅