Cosine tương tự giữa 2 danh sách số

Tôi cần tính toán sự giống nhau về cosin giữa hai danh sách , giả sử ví dụ danh sách 1 là dataSetIvà danh sách 2 là dataSetII. Tôi không thể sử dụng bất cứ thứ gì như numpy hoặc mô-đun thống kê. Tôi phải sử dụng các mô-đun phổ biến (toán học, v.v.) (và ít mô-đun nhất có thể, để giảm thời gian sử dụng).

Hãy nói dataSetIlà [3, 45, 7, 2]và dataSetIIđang [2, 54, 13, 15]. Độ dài của các danh sách luôn bằng nhau.

Tất nhiên, sự giống nhau về cosine là giữa 0 và 1 , và vì lợi ích của nó, nó sẽ được làm tròn đến số thập phân thứ ba hoặc thứ tư với format(round(cosine, 3)).

Cảm ơn bạn rất nhiều trước vì đã giúp đỡ.

Bạn nên thử SciPy . Nó có một loạt các quy trình khoa học hữu ích, chẳng hạn như "quy trình tính toán tích phân số, giải phương trình vi phân, tối ưu hóa và ma trận thưa thớt." Nó sử dụng NumPy được tối ưu hóa siêu nhanh để xử lý số của nó. Xem tại đây để cài đặt.

Lưu ý rằng spatial.distance.cosine tính khoảng cách chứ không phải tính tương tự. Vì vậy, bạn phải trừ giá trị cho 1 để có được sự tương tự .

from scipy import spatial

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

một phiên bản khác numpychỉ dựa trên

from numpy import dot
from numpy.linalg import norm

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

Bạn có thể sử dụng tài liệucosine_similarity biểu mẫu hàmsklearn.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]])

Tôi không cho rằng hiệu suất quan trọng ở đây, nhưng tôi không thể cưỡng lại. Hàm zip () hoàn toàn sao chép lại cả hai vectơ (thực ra là chuyển vị ma trận) chỉ để lấy dữ liệu theo thứ tự "Pythonic". Sẽ rất thú vị khi thời gian thực hiện các đai ốc:

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

Điều đó vượt qua tiếng ồn giống như C của việc trích xuất từng phần tử một, nhưng không sao chép mảng hàng loạt và hoàn thành mọi thứ quan trọng trong một vòng lặp for duy nhất và sử dụng một căn bậc hai.

ETA: Cuộc gọi in được cập nhật thành một hàm. (Bản gốc là Python 2.7, không phải 3.3. Hiện tại chạy dưới Python 2.7 vớifrom __future__ import print_function câu lệnh.) Đầu ra giống nhau.

CPYthon 2.7.3 trên 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

Vì vậy, cách unpythonic nhanh hơn khoảng 3,6 lần trong trường hợp này.

mà không sử dụng bất kỳ hàng nhập khẩu nào

math.sqrt (x)

có thể được thay thế bằng

x ** .5

mà không sử dụng numpy.dot (), bạn phải tạo hàm chấm của riêng mình bằng cách sử dụng tính năng hiểu danh sách:

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

và sau đó nó chỉ là một vấn đề đơn giản của việc áp dụng công thức tương tự cosin:

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

Tôi đã làm điểm chuẩn dựa trên một số câu trả lời trong câu hỏi và đoạn mã sau được cho là lựa chọn tốt nhất:

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)

Kết quả làm cho tôi ngạc nhiên rằng việc thực hiện dựa trên scipykhông phải là nhanh nhất. Tôi đã lập hồ sơ và thấy rằng cosine trong scipy mất rất nhiều thời gian để truyền một vector từ danh sách python sang mảng 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)

Bạn có thể làm tròn nó sau khi tính toán:

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

Nếu bạn muốn nó thực sự ngắn, bạn có thể sử dụng một lớp lót này:

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

Bạn có thể làm điều này bằng Python bằng cách sử dụng hàm đơn giản:

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)

Sử dụng numpy so sánh một danh sách các số với nhiều danh sách (ma trậ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]

Bạn có thể sử dụng hàm đơn giản này để tính toán độ tương tự của cosin:

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

Nếu bạn đã sử dụng PyTorch , bạn nên sử dụng triển khai CosineSimilarity của họ .

Giả sử bạn có hai nchiều numpy.ndarray, v1và v2, tức là hình dạng của chúng là cả hai (n,). Đây là cách bạn có được sự giống nhau về cosine của chúng:

import torch
import torch.nn as nn

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

Hoặc giả sử bạn có hai chữ numpy.ndarrays w1và w2, có hình dạng của cả hai (m, n). Phần sau sẽ cung cấp cho bạn danh sách các điểm giống nhau về cosin, mỗi điểm là độ tương đồng về cosin giữa một hàng trong w1và hàng tương ứng trong w2:

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

Tất cả các câu trả lời đều tuyệt vời cho những trường hợp bạn không thể sử dụng NumPy. Nếu bạn có thể, đây là một cách tiếp cận khác:

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)

Cũng nên nhớ về EPSILON = 1e-07việc đảm bảo sự phân chia.