cosinus similarité

Question

I calculé les valeurs tf / idf de deux documents. Voici les valeurs tf / idf:

1.txt
0.0
0.5
2.txt
0.0
0.5

Les documents sont comme:

1.txt = > dog cat
2.txt = > cat elephant

Comment puis-je utiliser ces valeurs pour calculer la similarité cosinus?

Je sais que je dois calculer le produit scalaire, puis trouver la distance et diviser produit scalaire par celui-ci. Comment puis-je calculer cela en utilisant mes valeurs?

Une autre question: Est-il important que les deux documents devraient avoir le même nombre de mots

Answer 1

            a * b
sim(a,b) =--------
           |a|*|b|

a * b est le produit scalaire

quelques détails:

def dot(a,b):
  n = length(a)
  sum = 0
  for i in xrange(n):
    sum += a[i] * b[i];
  return sum

def norm(a):
  n = length(a)
  for i in xrange(n):
    sum += a[i] * a[i]
  return math.sqrt(sum)

def cossim(a,b):
  return dot(a,b) / (norm(a) * norm(b))

oui. dans une certaine mesure, a et b doivent avoir la même longueur. mais a et b ont généralement une représentation parcimonieuse, il vous suffit de stocker des entrées non nulles et vous pouvez calculer la norme et le point plus rapide.

Answer 2

implémentation simple de code Java:

  static double cosine_similarity(Map<String, Double> v1, Map<String, Double> v2) {
            Set<String> both = Sets.newHashSet(v1.keySet());
            both.retainAll(v2.keySet());
            double sclar = 0, norm1 = 0, norm2 = 0;
            for (String k : both) sclar += v1.get(k) * v2.get(k);
            for (String k : v1.keySet()) norm1 += v1.get(k) * v1.get(k);
            for (String k : v2.keySet()) norm2 += v2.get(k) * v2.get(k);
            return sclar / Math.sqrt(norm1 * norm2);
    }

Answer 3

1) Calculer tf-idf (En général, mieux que tf seul, mais dépend entièrement de votre ensemble de données et l'exigence)

De wiki (en ce qui concerne idf)

  

Un facteur de fréquence de document inverse est incorporé qui diminue   le poids des termes qui se produisent très souvent dans l'ensemble des documents et   augmente le poids des termes qui se produisent rarement.

2) Non, ce n'est pas important que les deux documents ont le même nombre de mots.

3) Vous pouvez trouver tf-idf ou cosine-similarity dans toutes les langues de nos jours en invoquant une machine fonction de bibliothèque d'apprentissage. Je préfère python

code Python pour calculer tf-idf et cosinus similitude (en utilisant scikit-learn 0.18.2 )

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
# example dataset
from sklearn.datasets import fetch_20newsgroups

# replace with your method to get data
example_data = fetch_20newsgroups(subset='all').data

max_features_for_tfidf = 10000
is_idf = True 

vectorizer = TfidfVectorizer(max_df=0.5, max_features=max_features_for_tf_idf,
                             min_df=2, stop_words='english',
                             use_idf=is_idf)


X_Mat = vectorizer.fit_transform(example_data)

# calculate cosine similarity between samples in X with samples in Y
cosine_sim = cosine_similarity(X=X_Mat, Y=X_Mat)

4) Vous pourriez être intéressé par tronquée Valeur Singulier décomposition (SVD)