Python: tf-idf-cosine: um Dokumentähnlichkeit zu finden

Ich folgte einem Tutorial, das in Teil 1 und Teil 2 verfügbar war . Leider hatte der Autor nicht die Zeit für den letzten Abschnitt, in dem die Kosinusähnlichkeit verwendet wurde, um den Abstand zwischen zwei Dokumenten tatsächlich zu ermitteln. Ich habe die Beispiele im Artikel mit Hilfe des folgenden Links von stackoverflow befolgt , einschließlich des im obigen Link erwähnten Codes (nur um das Leben einfacher zu machen).

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from nltk.corpus import stopwords
import numpy as np
import numpy.linalg as LA

train_set = ["The sky is blue.", "The sun is bright."]  # Documents
test_set = ["The sun in the sky is bright."]  # Query
stopWords = stopwords.words('english')

vectorizer = CountVectorizer(stop_words = stopWords)
#print vectorizer
transformer = TfidfTransformer()
#print transformer

trainVectorizerArray = vectorizer.fit_transform(train_set).toarray()
testVectorizerArray = vectorizer.transform(test_set).toarray()
print 'Fit Vectorizer to train set', trainVectorizerArray
print 'Transform Vectorizer to test set', testVectorizerArray

transformer.fit(trainVectorizerArray)
print
print transformer.transform(trainVectorizerArray).toarray()

transformer.fit(testVectorizerArray)
print 
tfidf = transformer.transform(testVectorizerArray)
print tfidf.todense()

Aufgrund des obigen Codes habe ich die folgende Matrix

Fit Vectorizer to train set [[1 0 1 0]
 [0 1 0 1]]
Transform Vectorizer to test set [[0 1 1 1]]

[[ 0.70710678  0.          0.70710678  0.        ]
 [ 0.          0.70710678  0.          0.70710678]]

[[ 0.          0.57735027  0.57735027  0.57735027]]

Ich bin nicht sicher, wie ich diese Ausgabe verwenden soll, um die Kosinusähnlichkeit zu berechnen. Ich weiß, wie man die Kosinusähnlichkeit in Bezug auf zwei Vektoren ähnlicher Länge implementiert, aber hier bin ich nicht sicher, wie ich die beiden Vektoren identifizieren soll.

Wenn Sie zunächst Zählfunktionen extrahieren und die TF-IDF-Normalisierung und die zeilenweise euklidische Normalisierung anwenden möchten, können Sie dies in einem Arbeitsgang tun mit TfidfVectorizer:

>>> from sklearn.feature_extraction.text import TfidfVectorizer
>>> from sklearn.datasets import fetch_20newsgroups
>>> twenty = fetch_20newsgroups()

>>> tfidf = TfidfVectorizer().fit_transform(twenty.data)
>>> tfidf
<11314x130088 sparse matrix of type '<type 'numpy.float64'>'
    with 1787553 stored elements in Compressed Sparse Row format>

Um nun die Kosinusabstände eines Dokuments (z. B. des ersten im Datensatz) und aller anderen Dokumente zu ermitteln, müssen Sie nur die Punktprodukte des ersten Vektors mit allen anderen berechnen, da die tfidf-Vektoren bereits zeilennormalisiert sind.

Wie von Chris Clark in den Kommentaren und hier erklärt erklärt, berücksichtigt die Cosinus-Ähnlichkeit nicht die Größe der Vektoren. Zeilennormalisierte haben eine Größe von 1 und daher reicht der lineare Kernel aus, um die Ähnlichkeitswerte zu berechnen.

Die Scipy-Sparse-Matrix-API ist etwas seltsam (nicht so flexibel wie dichte N-dimensionale Numpy-Arrays). Um den ersten Vektor zu erhalten, müssen Sie die Matrix zeilenweise aufteilen, um eine Submatrix mit einer einzelnen Zeile zu erhalten:

>>> tfidf[0:1]
<1x130088 sparse matrix of type '<type 'numpy.float64'>'
    with 89 stored elements in Compressed Sparse Row format>

scikit-learn bietet bereits paarweise Metriken (auch bekannt als Kernel in der Sprache des maschinellen Lernens), die sowohl für dichte als auch für spärliche Darstellungen von Vektorsammlungen funktionieren. In diesem Fall benötigen wir ein Punktprodukt, das auch als linearer Kernel bezeichnet wird:

>>> from sklearn.metrics.pairwise import linear_kernel
>>> cosine_similarities = linear_kernel(tfidf[0:1], tfidf).flatten()
>>> cosine_similarities
array([ 1.        ,  0.04405952,  0.11016969, ...,  0.04433602,
    0.04457106,  0.03293218])

Um die Top 5 verwandten Dokumente zu finden, können wir daher argsortein negatives Array-Slicing verwenden (die meisten verwandten Dokumente haben die höchsten Kosinus-Ähnlichkeitswerte, daher am Ende des Arrays mit sortierten Indizes):

>>> related_docs_indices = cosine_similarities.argsort()[:-5:-1]
>>> related_docs_indices
array([    0,   958, 10576,  3277])
>>> cosine_similarities[related_docs_indices]
array([ 1.        ,  0.54967926,  0.32902194,  0.2825788 ])

Das erste Ergebnis ist eine Überprüfung der Integrität: Wir finden das Abfragedokument als das ähnlichste Dokument mit einer Kosinus-Ähnlichkeitsbewertung von 1, die den folgenden Text enthält:

>>> print twenty.data[0]
From: lerxst@wam.umd.edu (where's my thing)
Subject: WHAT car is this!?
Nntp-Posting-Host: rac3.wam.umd.edu
Organization: University of Maryland, College Park
Lines: 15

 I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.

Thanks,
- IL
   ---- brought to you by your neighborhood Lerxst ----

Das zweitähnlichste Dokument ist eine Antwort, die die ursprüngliche Nachricht zitiert und daher viele gebräuchliche Wörter enthält:

>>> print twenty.data[958]
From: rseymour@reed.edu (Robert Seymour)
Subject: Re: WHAT car is this!?
Article-I.D.: reed.1993Apr21.032905.29286
Reply-To: rseymour@reed.edu
Organization: Reed College, Portland, OR
Lines: 26

In article <1993Apr20.174246.14375@wam.umd.edu> lerxst@wam.umd.edu (where's my
thing) writes:
>
>  I was wondering if anyone out there could enlighten me on this car I saw
> the other day. It was a 2-door sports car, looked to be from the late 60s/
> early 70s. It was called a Bricklin. The doors were really small. In
addition,
> the front bumper was separate from the rest of the body. This is
> all I know. If anyone can tellme a model name, engine specs, years
> of production, where this car is made, history, or whatever info you
> have on this funky looking car, please e-mail.

Bricklins were manufactured in the 70s with engines from Ford. They are rather
odd looking with the encased front bumper. There aren't a lot of them around,
but Hemmings (Motor News) ususally has ten or so listed. Basically, they are a
performance Ford with new styling slapped on top.

>    ---- brought to you by your neighborhood Lerxst ----

Rush fan?

--
Robert Seymour              rseymour@reed.edu
Physics and Philosophy, Reed College    (NeXTmail accepted)
Artificial Life Project         Reed College
Reed Solar Energy Project (SolTrain)    Portland, OR

Mit Hilfe des Kommentars von @ excray gelingt es mir, die Antwort herauszufinden: Wir müssen tatsächlich eine einfache for-Schleife schreiben, um über die beiden Arrays zu iterieren, die die Zugdaten und Testdaten darstellen.

Implementieren Sie zunächst eine einfache Lambda-Funktion, um die Formel für die Kosinusberechnung zu speichern:

cosine_function = lambda a, b : round(np.inner(a, b)/(LA.norm(a)*LA.norm(b)), 3)

Und dann schreiben Sie einfach eine einfache for-Schleife, um über den to-Vektor zu iterieren. Die Logik gilt für jeden "Für jeden Vektor in trainVectorizerArray müssen Sie die Cosinus-Ähnlichkeit mit dem Vektor in testVectorizerArray finden."

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from nltk.corpus import stopwords
import numpy as np
import numpy.linalg as LA

train_set = ["The sky is blue.", "The sun is bright."] #Documents
test_set = ["The sun in the sky is bright."] #Query
stopWords = stopwords.words('english')

vectorizer = CountVectorizer(stop_words = stopWords)
#print vectorizer
transformer = TfidfTransformer()
#print transformer

trainVectorizerArray = vectorizer.fit_transform(train_set).toarray()
testVectorizerArray = vectorizer.transform(test_set).toarray()
print 'Fit Vectorizer to train set', trainVectorizerArray
print 'Transform Vectorizer to test set', testVectorizerArray
cx = lambda a, b : round(np.inner(a, b)/(LA.norm(a)*LA.norm(b)), 3)

for vector in trainVectorizerArray:
    print vector
    for testV in testVectorizerArray:
        print testV
        cosine = cx(vector, testV)
        print cosine

transformer.fit(trainVectorizerArray)
print
print transformer.transform(trainVectorizerArray).toarray()

transformer.fit(testVectorizerArray)
print 
tfidf = transformer.transform(testVectorizerArray)
print tfidf.todense()

Hier ist die Ausgabe:

Fit Vectorizer to train set [[1 0 1 0]
 [0 1 0 1]]
Transform Vectorizer to test set [[0 1 1 1]]
[1 0 1 0]
[0 1 1 1]
0.408
[0 1 0 1]
[0 1 1 1]
0.816

[[ 0.70710678  0.          0.70710678  0.        ]
 [ 0.          0.70710678  0.          0.70710678]]

[[ 0.          0.57735027  0.57735027  0.57735027]]

Ich weiß, es ist ein alter Beitrag. Ich habe jedoch das Paket http://scikit-learn.sourceforge.net/stable/ ausprobiert . Hier ist mein Code, um die Kosinusähnlichkeit zu finden. Die Frage war, wie Sie die Kosinusähnlichkeit mit diesem Paket berechnen und hier ist mein Code dafür

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.feature_extraction.text import TfidfVectorizer

f = open("/root/Myfolder/scoringDocuments/doc1")
doc1 = str.decode(f.read(), "UTF-8", "ignore")
f = open("/root/Myfolder/scoringDocuments/doc2")
doc2 = str.decode(f.read(), "UTF-8", "ignore")
f = open("/root/Myfolder/scoringDocuments/doc3")
doc3 = str.decode(f.read(), "UTF-8", "ignore")

train_set = ["president of India",doc1, doc2, doc3]

tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix_train = tfidf_vectorizer.fit_transform(train_set)  #finds the tfidf score with normalization
print "cosine scores ==> ",cosine_similarity(tfidf_matrix_train[0:1], tfidf_matrix_train)  #here the first element of tfidf_matrix_train is matched with other three elements

Angenommen, die Abfrage ist das erste Element von train_set und doc1, doc2 und doc3 sind die Dokumente, die ich mithilfe der Kosinusähnlichkeit bewerten möchte. dann kann ich diesen Code verwenden.

Auch die in der Frage bereitgestellten Tutorials waren sehr nützlich. Hier sind alle Teile dafür Teil I , Teil II , Teil III

Die Ausgabe wird wie folgt sein:

[[ 1.          0.07102631  0.02731343  0.06348799]]

Hier stellt 1 dar, dass die Abfrage mit sich selbst übereinstimmt, und die anderen drei sind die Bewertungen für die Zuordnung der Abfrage zu den jeweiligen Dokumenten.

Lassen Sie mich Ihnen ein weiteres von mir geschriebenes Tutorial geben. Es beantwortet Ihre Frage, erklärt aber auch, warum wir einige der Dinge tun. Ich habe auch versucht, es kurz zu machen.

Sie haben also eine, list_of_documentsdie nur ein Array von Zeichenfolgen ist, und eine andere, documentdie nur eine Zeichenfolge ist. Sie müssen ein solches Dokument aus dem Dokument finden list_of_documents, das dem am ähnlichsten ist document.

Kombinieren wir sie miteinander: documents = list_of_documents + [document]

Beginnen wir mit Abhängigkeiten. Es wird klar, warum wir jeden von ihnen verwenden.

from nltk.corpus import stopwords
import string
from nltk.tokenize import wordpunct_tokenize as tokenize
from nltk.stem.porter import PorterStemmer
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.spatial.distance import cosine

Einer der Ansätze, die verwendet werden können, ist eine Tüte mit Wörtern Word Ansatz, bei dem wir jedes Wort im Dokument unabhängig von anderen behandeln und alle zusammen in die große Tasche werfen. Unter einem Gesichtspunkt verliert es viele Informationen (wie zum Beispiel, wie die Wörter verbunden sind), aber unter einem anderen Gesichtspunkt macht es das Modell einfach.

Im Englischen und in jeder anderen menschlichen Sprache gibt es viele "nutzlose" Wörter wie "a", "the", "in", die so häufig vorkommen, dass sie nicht viel Bedeutung haben. Sie werden Stoppwörter genannt und es ist eine gute Idee, sie zu entfernen. Eine andere Sache, die man bemerken kann, ist, dass Wörter wie "analysieren", "Analysator", "Analyse" wirklich ähnlich sind. Sie haben eine gemeinsame Wurzel und alle können in nur ein Wort umgewandelt werden. Dieser Prozess wird als Stemming bezeichnet und es gibt verschiedene Stemmers, die sich in Geschwindigkeit, Aggressivität usw. unterscheiden. Also transformieren wir jedes der Dokumente in eine Liste von Wortstämmen ohne Stoppwörter. Außerdem verwerfen wir alle Satzzeichen.

porter = PorterStemmer()
stop_words = set(stopwords.words('english'))

modified_arr = [[porter.stem(i.lower()) for i in tokenize(d.translate(None, string.punctuation)) if i.lower() not in stop_words] for d in documents]

Wie hilft uns diese Wortsammlung? Stellen Sie sich vor wir 3 Taschen haben: [a, b, c], [a, c, a]und [b, c, d]. Wir können sie in der Basis in Vektoren umwandeln [a, b, c, d]. Also haben wir mit Vektoren am Ende: [1, 1, 1, 0], [2, 0, 1, 0]und [0, 1, 1, 1]. Ähnliches gilt für unsere Dokumente (nur die Vektoren werden viel zu lang sein). Jetzt sehen wir, dass wir viele Wörter entfernt und andere gestemmt haben, um auch die Dimensionen der Vektoren zu verringern. Hier gibt es nur interessante Beobachtungen. Längere Dokumente enthalten weitaus mehr positive Elemente als kürzere. Deshalb ist es hilfreich, den Vektor zu normalisieren. Dies wird als Häufigkeit TF bezeichnet. Die Benutzer verwendeten auch zusätzliche Informationen darüber, wie oft das Wort in anderen Dokumenten verwendet wird - inverse Dokumenthäufigkeit IDF. Zusammen haben wir eine metrische TF-IDF, die einige Geschmacksrichtungen hat. Dies kann mit einer Zeile in sklearn erreicht werden :-)

modified_doc = [' '.join(i) for i in modified_arr] # this is only to convert our list of lists to list of strings that vectorizer uses.
tf_idf = TfidfVectorizer().fit_transform(modified_doc)

Tatsächlich ermöglicht der Vektorisierer viele Dinge wie das Entfernen von Stoppwörtern und das Verkleinern. Ich habe sie nur in einem separaten Schritt ausgeführt, da sklearn keine nicht englischen Stoppwörter hat, nltk jedoch.

Wir haben also alle Vektoren berechnet. Der letzte Schritt besteht darin, herauszufinden, welcher dem letzten am ähnlichsten ist. Es gibt verschiedene Möglichkeiten, dies zu erreichen. Eine davon ist die euklidische Distanz, die aus dem hier diskutierten Grund nicht so groß ist . Ein anderer Ansatz ist die Kosinusähnlichkeit . Wir iterieren alle Dokumente und berechnen die Kosinusähnlichkeit zwischen dem Dokument und dem letzten:

l = len(documents) - 1
for i in xrange(l):
    minimum = (1, None)
    minimum = min((cosine(tf_idf[i].todense(), tf_idf[l + 1].todense()), i), minimum)
print minimum

Jetzt enthält Minimum Informationen über das beste Dokument und seine Punktzahl.

Dies sollte Ihnen helfen.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity  

tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(train_set)
print tfidf_matrix
cosine = cosine_similarity(tfidf_matrix[length-1], tfidf_matrix)
print cosine

und Ausgabe wird sein:

[[ 0.34949812  0.81649658  1.        ]]

Hier ist eine Funktion, die Ihre Testdaten mit den Trainingsdaten vergleicht, wobei der Tf-Idf-Transformator mit den Trainingsdaten ausgestattet ist. Der Vorteil ist, dass Sie schnell schwenken oder gruppieren können, um die n nächstgelegenen Elemente zu finden, und dass die Berechnungen in Bezug auf die Matrix nach unten erfolgen.

def create_tokenizer_score(new_series, train_series, tokenizer):
    """
    return the tf idf score of each possible pairs of documents
    Args:
        new_series (pd.Series): new data (To compare against train data)
        train_series (pd.Series): train data (To fit the tf-idf transformer)
    Returns:
        pd.DataFrame
    """

    train_tfidf = tokenizer.fit_transform(train_series)
    new_tfidf = tokenizer.transform(new_series)
    X = pd.DataFrame(cosine_similarity(new_tfidf, train_tfidf), columns=train_series.index)
    X['ix_new'] = new_series.index
    score = pd.melt(
        X,
        id_vars='ix_new',
        var_name='ix_train',
        value_name='score'
    )
    return score

train_set = pd.Series(["The sky is blue.", "The sun is bright."])
test_set = pd.Series(["The sun in the sky is bright."])
tokenizer = TfidfVectorizer() # initiate here your own tokenizer (TfidfVectorizer, CountVectorizer, with stopwords...)
score = create_tokenizer_score(train_series=train_set, new_series=test_set, tokenizer=tokenizer)
score

   ix_new   ix_train    score
0   0       0       0.617034
1   0       1       0.862012