Hoe u Cosine Similarity in Python implementeert

Cosine similarity heeft verschillende toepassingen in de echte wereld, en door het gebruik van embedding vectoren, kunnen we echte wereld betekenissen op een programmeerbare manier vergelijken. Python is een van de populairste talen voor data wetenschap, en het biedt diverse bibliotheken om cosinus similariteit gemakkelijk te berekenen. In dit artikel zullen we bespreken hoe je cosinus similariteit in Python kunt implementeren met behulp van de Scikit-Learn en NumPy bibliotheken. 

Wat Is Cosine Similarity?

Cosine similariteit is een maatstaf voor gelijkenis tussen twee niet-nul vectoren in een n-dimensionale ruimte. Het wordt gebruikt in verschillende toepassingen, zoals tekstanalyse en aanbevelingssystemen, om te bepalen hoe gelijkende twee vectoren zijn in termen van hun richting in de vectorruimte.

Cosine Similarity Formule

De cosinus similariteit tussen twee vectoren, A en B, wordt berekend met behulp van de volgende formule:

Cosine Similarity (A, B) = (A · B) / (||A|| * ||B||)

In deze formule staat A · B voor het inproduct van vectoren A en B. Dit wordt berekend door de corresponderende componenten van de twee vectoren te vermenigvuldigen en de resultaten op te tellen. ||A|| staat voor de Euclidische norm (grootte) van vector A, die de wortel is van de som van de kwadraten van zijn componenten. Het wordt berekend als ||A|| = √(A₁² + A₂² + … + Aₙ²). ||B|| staat voor de Euclidische norm (grootte) van vector B, berekend op dezelfde manier als ||A||.

Hoe Cosine Similarity te Berekenen

Om de cosine similarity te berekenen, moet je eerst de berekening voor het inproduct van de twee vectoren voltooien. Verdeel dit vervolgens door het product van hun magnitudes. De resulterende waarde zal in het bereik van -1 tot 1 liggen, waarbij:

• Als de cosine similarity 1 is, betekent dit dat de vectoren dezelfde richting hebben en perfect gelijk zijn.
• Als de cosine similarity 0 is, betekent dit dat de vectoren loodrecht op elkaar staan en geen gelijkenis hebben.
• Als de cosine similarity -1 is, betekent dit dat de vectoren tegengestelde richtingen hebben en perfect ongelijk zijn.

Bij tekstanalyse wordt cosine similarity gebruikt om de gelijkenis tussen documentvectoren te meten, waarbij elk document wordt voorgesteld als een vector in een hoogdimensionale ruimte, met elke dimensie die overeenkomt met een term of woord in de corpus. Door de cosine similarity tussen documentvectoren te berekenen, kun je bepalen hoe gelijk of ongelijk twee documenten aan elkaar zijn.

Bibliotheken voor Cosine Similarity Berekening

• NumPy: Uitstekend voor numerieke operaties en geoptimaliseerd voor snelheid.
• scikit-learn: Biedt verschillende machinaal leren algoritmen en bevat een methode voor cosinus-similariteit in zijn metrics-pakket.

Hier volgen enkele voorbeelden om te laten zien hoe cosinus-similariteit kan worden berekend met behulp van Python. We zullen onze twee nu bekende boekrecensievectoren [5,3,4] en [4,2,4] gebruiken. 

Rechttoe Python

Hoewel we dit eerder met de hand hebben berekend, kan een computer het natuurlijk ook! Hier leest u hoe u cosinus-similariteit kunt berekenen met behulp van Python zonder extra bibliotheken:

A = [5, 3, 4]

B = [4, 2, 4]

# Calculate dot product

dot_product = sum(a*b for a, b in zip(A, B))

# Calculate the magnitude of each vector

magnitude_A = sum(a*a for a in A)**0.5

magnitude_B = sum(b*b for b in B)**0.5

# Compute cosine similarity

cosine_similarity = dot_product / (magnitude_A * magnitude_B)

print(f"Cosine Similarity using standard Python: {cosine_similarity}")

NumPy

Ingebedde vectoren zullen meestal veel dimensies hebben – honderden, duizenden, zelfs miljoenen of meer! Met NumPy kunt u cosinus-similariteit berekenen met behulp van array-operaties, die zeer geoptimaliseerd zijn. 

import numpy as np

A = np.array([5, 3, 4])

B = np.array([4, 2, 4])

dot_product = np.dot(A, B)

magnitude_A = np.linalg.norm(A)

magnitude_B = np.linalg.norm(B)

cosine_similarity = dot_product / (magnitude_A * magnitude_B)

print(f"Cosine Similarity using NumPy: {cosine_similarity}")

Scikit-Learn

De cosine_similarity functie van scikit-learn maakt het nog gemakkelijker om geoptimaliseerde cosinus-similariteitsoperaties te berekenen:

from sklearn.metrics.pairwise import cosine_similarity

A = np.array([[5, 3, 4]])

B = np.array([[4, 2, 4]])

cosine_similarity_result = cosine_similarity(A, B)

print(f"Cosine Similarity using scikit-learn: {cosine_similarity_result[0][0]}")

Tips voor het optimaliseren van cosinus-similariteitsberekeningen in Python

Als u Python gaat gebruiken om cosinus-similariteit direct te berekenen, zijn er enkele zaken om rekening mee te houden:

• Gebruik geoptimaliseerde bibliotheken zoals NumPy of scikit-learn: Deze bibliotheken zijn geoptimaliseerd voor prestaties en zijn over het algemeen sneller dan pure Python.
• Gebruik Numba:Numba is een open-source JIT-compiler voor Python en NumPy-code, speciaal ontworpen om wetenschappelijke berekeningen te optimaliseren.
• Gebruik GPU’s: Als u toegang heeft tot een GPU, gebruik Python-bibliotheken zoals Tensorflow die zijn geoptimaliseerd voor gebruik op een GPU.
• Paralleliseer berekeningen: Als u de hardwarecapaciteiten heeft, overweeg dan om uw berekeningen te paralleliseren om ze te versnellen.

Zoek grote aantallen vectoren met Vector Search op AstraDB

Als u grote aantallen vectoren moet doorzoeken, kunt u het efficiënter en schaalbaarder vinden om een vectordatabase te gebruiken zoals DataStax Astra’s Vector Search-mogelijkheid. Vector Search op Astra DB biedt een krachtig platform om vectorzoekopdrachten uit te voeren met ingebouwde cosinus gelijkenisberekeningen, zodat u meer inzichten uit uw gegevens kunt halen.