2 Numara Listesi Arasındaki Kosinüs Benzerliği

İki liste arasındaki kosinüs benzerliğini hesaplamam gerekiyor , örneğin diyelim ki liste 1 olan liste 2 . Numpy veya istatistik modülü gibi bir şey kullanamıyorum . Ortak modüller (matematik vb.) (Ve harcanan zamanı azaltmak için mümkün olan en az modül) kullanmalıyım.dataSetIdataSetII

Diyelim ki dataSetIöyle [3, 45, 7, 2]ve dataSetIIöyle [2, 54, 13, 15]. Listelerin uzunluğu her zaman eşittir.

Elbette, kosinüs benzerliği 0 ile 1 arasındadır ve bunun uğruna üçüncü veya dördüncü ondalık sayıya yuvarlanacaktır format(round(cosine, 3)).

Yardımınız için şimdiden çok teşekkür ederim.

SciPy'yi denemelisin . Örneğin, "integralleri sayısal olarak hesaplama, diferansiyel denklemleri çözme, optimizasyon ve seyrek matrisler için yordamlar" gibi birçok yararlı bilimsel rutine sahiptir. Sayı hesaplaması için süper hızlı optimize edilmiş NumPy'yi kullanır. Kurulum için buraya bakın .

Spatial.distance.cosine'nin benzerliği değil mesafeyi hesapladığını unutmayın . Yani, benzerliği elde etmek için değeri 1'den çıkarmanız gerekir .

from scipy import spatial

dataSetI = [3, 45, 7, 2]
dataSetII = [2, 54, 13, 15]
result = 1 - spatial.distance.cosine(dataSetI, dataSetII)

numpysadece başka bir sürüm

from numpy import dot
from numpy.linalg import norm

cos_sim = dot(a, b)/(norm(a)*norm(b))

cosine_similarityİşlev formu belgelerini kullanabilirsinizsklearn.metrics.pairwise

In [23]: from sklearn.metrics.pairwise import cosine_similarity

In [24]: cosine_similarity([[1, 0, -1]], [[-1,-1, 0]])
Out[24]: array([[-0.5]])

Burada performansın pek önemli olduğunu sanmıyorum ama karşı koyamıyorum. Zip () işlevi, verileri "Pythonic" sırasına göre elde etmek için her iki vektörü de (aslında bir matris devrikinden daha fazlası) tamamen yeniden kopyalar. Somun ve cıvata uygulamasını zamanlamak ilginç olurdu:

import math
def cosine_similarity(v1,v2):
    "compute cosine similarity of v1 to v2: (v1 dot v2)/{||v1||*||v2||)"
    sumxx, sumxy, sumyy = 0, 0, 0
    for i in range(len(v1)):
        x = v1[i]; y = v2[i]
        sumxx += x*x
        sumyy += y*y
        sumxy += x*y
    return sumxy/math.sqrt(sumxx*sumyy)

v1,v2 = [3, 45, 7, 2], [2, 54, 13, 15]
print(v1, v2, cosine_similarity(v1,v2))

Output: [3, 45, 7, 2] [2, 54, 13, 15] 0.972284251712

Bu, öğeleri birer birer ayıklamanın C benzeri gürültüsünden geçer, ancak toplu dizi kopyalaması yapmaz ve önemli her şeyi tek bir for döngüsünde yapar ve tek bir karekök kullanır.

ETA: Yazdırma çağrısı bir işlev olacak şekilde güncellendi. (Orijinal Python 2.7 idi, 3.3 değil. Şu anki Python 2.7 altında bir from __future__ import print_functionifade ile çalışıyor.) Çıktı her iki şekilde de aynı.

3.0GHz Core 2 Duo üzerinde CPYthon 2.7.3:

>>> timeit.timeit("cosine_similarity(v1,v2)",setup="from __main__ import cosine_similarity, v1, v2")
2.4261788514654654
>>> timeit.timeit("cosine_measure(v1,v2)",setup="from __main__ import cosine_measure, v1, v2")
8.794677709375264

Bu durumda, pirtonik olmayan yol yaklaşık 3.6 kat daha hızlıdır.

herhangi bir ithalat kullanmadan

Math.sqrt (x)

ile değiştirilebilir

x ** .5

numpy.dot () kullanmadan, liste anlamayı kullanarak kendi nokta işlevinizi oluşturmanız gerekir:

def dot(A,B): 
    return (sum(a*b for a,b in zip(A,B)))

ve sonra kosinüs benzerlik formülünü uygulamak basit bir mesele:

def cosine_similarity(a,b):
    return dot(a,b) / ( (dot(a,a) **.5) * (dot(b,b) ** .5) )

Sorudaki birkaç yanıtı temel alarak bir kıyaslama yaptım ve aşağıdaki ön bilginin en iyi seçim olduğuna inanılıyor:

def dot_product2(v1, v2):
    return sum(map(operator.mul, v1, v2))


def vector_cos5(v1, v2):
    prod = dot_product2(v1, v2)
    len1 = math.sqrt(dot_product2(v1, v1))
    len2 = math.sqrt(dot_product2(v2, v2))
    return prod / (len1 * len2)

Sonuç, temel alınan uygulamanın scipyen hızlısı olmaması beni şaşırttı . Profilimi çıkardım ve scipy'deki kosinüsün bir vektörü python listesinden numpy dizisine çevirmenin çok zaman aldığını gördüm.

import math
from itertools import izip

def dot_product(v1, v2):
    return sum(map(lambda x: x[0] * x[1], izip(v1, v2)))

def cosine_measure(v1, v2):
    prod = dot_product(v1, v2)
    len1 = math.sqrt(dot_product(v1, v1))
    len2 = math.sqrt(dot_product(v2, v2))
    return prod / (len1 * len2)

Hesapladıktan sonra yuvarlayabilirsiniz:

cosine = format(round(cosine_measure(v1, v2), 3))

Gerçekten kısa olmasını istiyorsanız, bu tek astarı kullanabilirsiniz:

from math import sqrt
from itertools import izip

def cosine_measure(v1, v2):
    return (lambda (x, y, z): x / sqrt(y * z))(reduce(lambda x, y: (x[0] + y[0] * y[1], x[1] + y[0]**2, x[2] + y[1]**2), izip(v1, v2), (0, 0, 0)))

Bunu Python'da basit bir işlev kullanarak yapabilirsiniz:

def get_cosine(text1, text2):
  vec1 = text1
  vec2 = text2
  intersection = set(vec1.keys()) & set(vec2.keys())
  numerator = sum([vec1[x] * vec2[x] for x in intersection])
  sum1 = sum([vec1[x]**2 for x in vec1.keys()])
  sum2 = sum([vec2[x]**2 for x in vec2.keys()])
  denominator = math.sqrt(sum1) * math.sqrt(sum2)
  if not denominator:
     return 0.0
  else:
     return round(float(numerator) / denominator, 3)
dataSet1 = [3, 45, 7, 2]
dataSet2 = [2, 54, 13, 15]
get_cosine(dataSet1, dataSet2)

Numpy kullanarak bir sayı listesini birden çok listeyle (matris) karşılaştırın:

def cosine_similarity(vector,matrix):
   return ( np.sum(vector*matrix,axis=1) / ( np.sqrt(np.sum(matrix**2,axis=1)) * np.sqrt(np.sum(vector**2)) ) )[::-1]

Kosinüs benzerliğini hesaplamak için bu basit işlevi kullanabilirsiniz:

def cosine_similarity(a, b):
return sum([i*j for i,j in zip(a, b)])/(math.sqrt(sum([i*i for i in a]))* math.sqrt(sum([i*i for i in b])))

Halihazırda PyTorch kullanıyorsanız , CosineSimilarity uygulamasına devam etmelisiniz .

İki olduğunu varsayalım nboyutlu numpy.ndarrays, v1ve v2onların şekiller hem yani (n,). Kosinüs benzerliğini şu şekilde elde edersiniz:

import torch
import torch.nn as nn

cos = nn.CosineSimilarity()
cos(torch.tensor([v1]), torch.tensor([v2])).item()

Yoksa iki olduğunu varsayın numpy.ndarrays w1ve w2kimin şekilleri hem, (m, n). Aşağıdakiler size kosinüs benzerliklerinin bir listesini verir, her biri bir satır w1ve içindeki karşılık gelen satır arasındaki kosinüs benzerliğidir w2:

cos(torch.tensor(w1), torch.tensor(w2)).tolist()

NumPy'yi kullanamayacağınız durumlar için tüm cevaplar harika. Yapabiliyorsanız, işte başka bir yaklaşım:

def cosine(x, y):
    dot_products = np.dot(x, y.T)
    norm_products = np.linalg.norm(x) * np.linalg.norm(y)
    return dot_products / (norm_products + EPSILON)

Ayrıca EPSILON = 1e-07bölünmeyi sağlamayı da aklınızda bulundurun .