Podobieństwo cosinusowe między 2 listami liczb

Muszę obliczyć podobieństwo cosinusowe między dwiema listami , powiedzmy na przykład lista 1, która jest dataSetIi lista 2, która jest dataSetII. Nie mogę używać niczego takiego jak numpy lub moduł statystyk. Muszę używać wspólnych modułów (matematyka itp.) (I możliwie najmniejszej liczby modułów, aby skrócić czas spędzony).

Powiedzmy, że dataSetIjest [3, 45, 7, 2]i dataSetIIjest [2, 54, 13, 15]. Długości list są zawsze równe.

Oczywiście podobieństwo cosinusowe mieści się w przedziale od 0 do 1 i ze względu na to zostanie zaokrąglone do trzeciego lub czwartego miejsca po przecinku za pomocą format(round(cosine, 3)).

Z góry dziękuję za pomoc.

Powinieneś spróbować SciPy . Zawiera wiele przydatnych naukowych procedur, na przykład „procedury numerycznego obliczania całek, rozwiązywania równań różniczkowych, optymalizacji i rzadkich macierzy”. Używa superszybkiego zoptymalizowanego NumPy do chrupania liczb. Zobacz tutaj, aby zainstalować.

Zauważ, że spatial.distance.cosine oblicza odległość , a nie podobieństwo. Musisz więc odjąć wartość od 1, aby uzyskać podobieństwo .

from scipy import spatial

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

inna wersja oparta numpytylko

from numpy import dot
from numpy.linalg import norm

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

Możesz użyć dokumentówcosine_similarity funkcji formularzysklearn.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]])

Nie sądzę, żeby wydajność miała tu duże znaczenie, ale nie mogę się oprzeć. Funkcja zip () całkowicie ponownie kopiuje oba wektory (właściwie to raczej transpozycja macierzy) tylko po to, aby uzyskać dane w „Pythonowej” kolejności. Byłoby ciekawie zaplanować wdrożenie nakrętek i śrub:

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

Przechodzi przez szum podobny do C podczas wyodrębniania elementów pojedynczo, ale nie powoduje masowego kopiowania tablicy i wykonuje wszystko, co ważne w pojedynczej pętli for, i wykorzystuje pojedynczy pierwiastek kwadratowy.

ETA: Zaktualizowano wywołanie drukowania, aby było funkcją. (Oryginał to Python 2.7, a nie 3.3. Bieżący działa pod Pythonem 2.7 z rozszerzeniemfrom __future__ import print_function instrukcją.) Dane wyjściowe są takie same, tak czy inaczej.

CPYthon 2.7.3 na 3,0 GHz Core 2 Duo:

>>> 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

Tak więc w tym przypadku sposób niepytoniczny jest około 3,6 razy szybszy.

bez użycia importu

math.sqrt (x)

można zastąpić

x ** .5

bez używania numpy.dot () musisz stworzyć własną funkcję kropkową używając funkcji list:

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

a wtedy jest to tylko prosta kwestia zastosowania wzoru na podobieństwo cosinusowe:

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

Zrobiłem test porównawczy na podstawie kilku odpowiedzi w pytaniu i uważa się, że następujący fragment jest najlepszym wyborem:

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)

Wynik zaskakuje mnie, że wdrożenie oparte o scipynie należy do najszybszych. Sprofilowałem i stwierdziłem, że cosinus w scipy zajmuje dużo czasu, aby rzutować wektor z listy Pythona na tablicę numpy.

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)

Możesz go zaokrąglić po obliczeniu:

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

Jeśli chcesz, żeby była naprawdę krótka, możesz użyć tej jednej linijki:

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)))

Możesz to zrobić w Pythonie za pomocą prostej funkcji:

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)

Używając numpy porównaj jedną listę liczb z wieloma listami (macierz):

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]

Możesz użyć tej prostej funkcji, aby obliczyć podobieństwo cosinusowe:

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])))

Jeśli używasz już PyTorch , powinieneś skorzystać z ich implementacji CosineSimilarity .

Przypuśćmy, że masz ndwuwymiarowe numpy.ndarrays, v1a v2więc ich kształty są oba (n,). Oto jak uzyskać ich podobieństwo cosinusowe:

import torch
import torch.nn as nn

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

Albo załóżmy, że masz dwa numpy.ndarrays w1i w2, które mają oba kształty (m, n). Poniżej znajduje się lista podobieństw cosinusowych, z których każde jest podobieństwem cosinusowym między wierszem w w1a odpowiadającym mu wierszem w w2:

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

Wszystkie odpowiedzi są świetne w sytuacjach, w których nie możesz używać NumPy. Jeśli możesz, oto inne podejście:

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)

Pamiętaj też o EPSILON = 1e-07zabezpieczeniu podziału.