Similitude cosinus entre 2 listes de nombres

J'ai besoin de calculer la similitude cosinus entre deux listes , disons par exemple la liste 1 qui est dataSetIet la liste 2 qui est dataSetII. Je ne peux rien utiliser comme numpy ou un module de statistiques. Je dois utiliser des modules communs (mathématiques, etc) (et le moins de modules possible, en plus, pour réduire le temps passé).

Disons dataSetIest [3, 45, 7, 2]et dataSetIIest [2, 54, 13, 15]. La longueur des listes est toujours égale.

Bien sûr, la similitude cosinus est comprise entre 0 et 1 , et pour cela, elle sera arrondie à la troisième ou quatrième décimale avec format(round(cosine, 3)).

Merci d'avance pour votre aide.

Vous devriez essayer SciPy . Il a un tas de routines scientifiques utiles, par exemple, "des routines pour calculer des intégrales numériquement, résoudre des équations différentielles, l'optimisation et des matrices clairsemées". Il utilise le NumPy optimisé ultra-rapide pour son calcul des nombres. Voir ici pour l'installation.

Notez que spatial.distance.cosine calcule la distance et non la similitude. Donc, vous devez soustraire la valeur de 1 pour obtenir la similitude .

from scipy import spatial

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

une autre version basée numpyuniquement sur

from numpy import dot
from numpy.linalg import norm

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

Vous pouvez utiliser cosine_similaritydes documents de formulaire de fonctionsklearn.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]])

Je ne pense pas que la performance compte beaucoup ici, mais je ne peux pas résister. La fonction zip () recopie complètement les deux vecteurs (plutôt une transposition matricielle, en fait) juste pour obtenir les données dans l'ordre "Pythonic". Il serait intéressant de chronométrer la mise en œuvre des écrous et boulons:

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

Cela passe par le bruit de type C d'extraction d'éléments un par un, mais ne fait pas de copie de tableau en bloc et fait tout ce qui est important dans une seule boucle for, et utilise une seule racine carrée.

ETA: appel d'impression mis à jour pour être une fonction. (L'original était Python 2.7, pas 3.3. Le courant fonctionne sous Python 2.7 avec unfrom __future__ import print_function instruction.) La sortie est la même, de toute façon.

CPYthon 2.7.3 sur 3.0GHz 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

Ainsi, la voie unpythonic est environ 3,6 fois plus rapide dans ce cas.

sans utiliser d'importations

math.sqrt (x)

peut être remplacé par

x ** .5

sans utiliser numpy.dot (), vous devez créer votre propre fonction de point en utilisant la compréhension de liste:

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

et puis il suffit d'appliquer la formule de similarité cosinus:

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

J'ai fait un benchmark basé sur plusieurs réponses à la question et l'extrait suivant est considéré comme le meilleur choix:

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)

Le résultat me surprend que l'implémentation basée sur scipyne soit pas la plus rapide. J'ai profilé et je trouve que le cosinus dans scipy prend beaucoup de temps pour convertir un vecteur de la liste python en tableau 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)

Vous pouvez l'arrondir après le calcul:

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

Si vous le voulez vraiment court, vous pouvez utiliser ce one-liner:

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

Vous pouvez le faire en Python en utilisant une fonction simple:

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)

En utilisant numpy, comparez une liste de nombres à plusieurs listes (matrice):

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]

Vous pouvez utiliser cette fonction simple pour calculer la similitude cosinus:

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

Si vous utilisez déjà PyTorch , vous devriez opter pour leur implémentation CosineSimilarity .

Supposons que vous ayez des s à deux ndimensions numpy.ndarray, v1et v2, c'est-à-dire que leurs formes sont les deux (n,). Voici comment obtenir leur similitude cosinus:

import torch
import torch.nn as nn

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

Ou supposons que vous ayez deux numpy.ndarrays w1et w2, dont les formes sont les deux (m, n). Ce qui suit vous donne une liste de similitudes en cosinus, chacune étant la similitude en cosinus entre une ligne dans w1et la ligne correspondante dans w2:

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

Toutes les réponses sont parfaites pour les situations où vous ne pouvez pas utiliser NumPy. Si vous le pouvez, voici une autre approche:

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)

Gardez également à l'esprit sur le point EPSILON = 1e-07de sécuriser la division.