अजगर: tf-idf-cosine: दस्तावेज़ समानता खोजने के लिए

Question 1

मैं एक ट्यूटोरियल का अनुसरण कर रहा था जो भाग १ और भाग २ में उपलब्ध था । दुर्भाग्य से लेखक के पास अंतिम खंड के लिए समय नहीं था, जिसमें वास्तव में दो दस्तावेजों के बीच की दूरी को खोजने के लिए कोसाइन समानता का उपयोग करना शामिल था। मैं से नीचे दिए गए लिंक की मदद से लेख में उदाहरण का पालन किया stackoverflow , शामिल कोड ऊपर के लिंक में बताया गया है (कर जीवन के लिए के रूप में बस इतनी आसान)

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

उपरोक्त कोड के परिणामस्वरूप मेरे पास निम्नलिखित मैट्रिक्स है

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

मुझे यह पता नहीं है कि कोसाइन समानता की गणना करने के लिए इस आउटपुट का उपयोग कैसे किया जाता है, मुझे पता है कि समान लंबाई के दो वैक्टर के संबंध में कॉज़ेन समानता को कैसे लागू किया जाए, लेकिन यहां मुझे यकीन नहीं है कि दो वैक्टर की पहचान कैसे करें।

Question 2

सबसे पहले, यदि आप गिनती सुविधाओं को निकालना चाहते हैं और TF-IDF सामान्यीकरण और पंक्ति-वार यूक्लिडियन सामान्यीकरण लागू करना चाहते हैं, तो आप इसे एक ऑपरेशन में कर सकते हैं 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>

अब एक दस्तावेज़ (जैसे कि डाटासेट में पहली) की कोसाइन दूरी और अन्य सभी को खोजने के लिए आपको केवल पहले वेक्टर के डॉट उत्पादों को अन्य सभी के साथ गणना करने की आवश्यकता है क्योंकि टैफिड वैक्टर पहले से ही पंक्ति-सामान्यीकृत हैं।

जैसा कि क्रिस क्लार्क ने टिप्पणियों में और यहां बताया है कोसाइन समानता समानता वैक्टर के परिमाण को ध्यान में नहीं रखती है। रो-सामान्यीकृत में 1 का परिमाण होता है और इसलिए समानता को मानों की गणना करने के लिए रैखिक कर्नेल पर्याप्त होता है।

स्कैपी विरल मैट्रिक्स एपीआई थोड़ा अजीब है (घने एन-आयामी सुन्न सरणियों के रूप में लचीला नहीं है)। पहला वेक्टर प्राप्त करने के लिए आपको एक पंक्ति के साथ सबमेट्रिक्स प्राप्त करने के लिए मैट्रिक्स रो-वार को स्लाइस करना होगा:

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

scikit-learn पहले से ही युग्मक मेट्रिक्स (मशीन लर्निंग पैरलेंस में उर्फ गुठली) प्रदान करता है जो वेक्टर संग्रह के घने और विरल प्रतिनिधित्व दोनों के लिए काम करते हैं। इस मामले में हमें एक डॉट उत्पाद की आवश्यकता होती है जिसे रैखिक कर्नेल के रूप में भी जाना जाता है:

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

इसलिए शीर्ष 5 संबंधित दस्तावेजों को खोजने के लिए, हम argsortकुछ नकारात्मक सरणी स्लाइसिंग का उपयोग कर सकते हैं (अधिकांश संबंधित दस्तावेजों में उच्चतम कोसाइनिटी समानता मूल्य हैं, इसलिए छँटाई गई सूचकांकों की सरणी के अंत में):

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

पहला परिणाम एक पवित्रता जांच है: हम क्वेरी दस्तावेज़ को 1 के कोसाइनिटी समानता स्कोर के साथ सबसे समान दस्तावेज़ के रूप में पाते हैं, जिसमें निम्न पाठ है:

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

दूसरा सबसे समान दस्तावेज एक उत्तर है जो मूल संदेश को उद्धृत करता है इसलिए इसमें कई सामान्य शब्द हैं:

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

Question 3

@ एक्सरे की टिप्पणी की मदद से, मैं इसका उत्तर जानने के लिए प्रबंधन करता हूं, जो हमें करने की आवश्यकता है वह वास्तव में दो सरणियों पर लूप के लिए एक सरल लिखना है जो ट्रेन डेटा और परीक्षण डेटा का प्रतिनिधित्व करता है।

सर्वप्रथम लौकिक गणना के सूत्र को धारण करने के लिए एक साधारण लंबोदर फ़ंक्शन लागू करें:

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

और फिर सदिश से वेक्टर पर पुनरावृति करने के लिए बस एक सरल लिखें, तर्क हर एक के लिए है "trainVectorizerArray में प्रत्येक वेक्टर के लिए, आपको testVectorizerArray में वेक्टर के साथ कोसाइन समानता को ढूंढना होगा।"

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

यहाँ उत्पादन है:

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

Question 4

मैं इसकी एक पुरानी पोस्ट जानता हूं। लेकिन मैंने http://scikit-learn.sourceforge.net/stable/ पैकेज की कोशिश की । यहाँ कोडीन समानता खोजने के लिए मेरा कोड है। सवाल यह था कि आप इस पैकेज के साथ कॉस्मिक समानता की गणना कैसे करेंगे और इसके लिए यहां मेरा कोड है

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

यहाँ मान लें कि क्वेरी train_set और doc1 का पहला तत्व है, doc2 और doc3 ऐसे दस्तावेज़ हैं, जिन्हें मैं कॉशन समानता की मदद से रैंक करना चाहता हूं। तब मैं इस कोड का उपयोग कर सकता हूं।

साथ ही प्रश्न में दिए गए ट्यूटोरियल बहुत उपयोगी थे। यहाँ इसके लिए सभी भाग भाग- I , भाग- II , भाग- III हैं

आउटपुट निम्नानुसार होगा:

[[ 1.          0.07102631  0.02731343  0.06348799]]

यहाँ 1 यह दर्शाता है कि क्वेरी अपने आप से मेल खाती है और अन्य तीन संबंधित दस्तावेजों के साथ क्वेरी के मिलान के लिए स्कोर हैं।

Question 5

मुझे आपके द्वारा लिखा गया एक और ट्यूटोरियल दीजिए। यह आपके प्रश्न का उत्तर देता है, लेकिन यह भी स्पष्टीकरण देता है कि हम कुछ चीजें क्यों कर रहे हैं। मैंने इसे संक्षिप्त करने की भी कोशिश की।

तो आपके पास एक है list_of_documentsजो सिर्फ तार की एक सरणी है और दूसरा documentजो सिर्फ एक स्ट्रिंग है। आपको इस तरह के दस्तावेज़ को खोजने की आवश्यकता list_of_documentsहै जो इसके समान हैdocument ।

चलो उन्हें एक साथ जोड़ते हैं: documents = list_of_documents + [document]

चलो निर्भरता के साथ शुरू करते हैं। यह स्पष्ट हो जाएगा कि हम उनमें से प्रत्येक का उपयोग क्यों करते हैं।

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

एक दृष्टिकोण जो उपयोग किया जा सकता है वह बैग-ऑफ-वर्ड है वर्ड दृष्टिकोण है, जहां हम प्रत्येक शब्द को दूसरों से स्वतंत्र दस्तावेज़ में व्यवहार करते हैं और बस उन सभी को एक साथ बड़े बैग में फेंक देते हैं। एक दृष्टिकोण से, यह बहुत सारी जानकारी खो देता है (जैसे शब्द कैसे जुड़े हैं), लेकिन दूसरे दृष्टिकोण से यह मॉडल को सरल बनाता है।

अंग्रेजी और किसी भी अन्य मानव भाषा में '' ए ',' द ',' 'जैसे बहुत सारे "बेकार" शब्द हैं जो इतने आम हैं कि उनमें बहुत अधिक अर्थ नहीं है। उन्हें स्टॉप शब्द कहा जाता है और उन्हें हटाने के लिए एक अच्छा विचार है। एक और बात जो नोटिस कर सकते हैं वह यह है कि 'विश्लेषण', 'विश्लेषक', 'विश्लेषण' जैसे शब्द वास्तव में समान हैं। उनके पास एक सामान्य जड़ है और सभी को केवल एक शब्द में बदला जा सकता है। इस प्रक्रिया को स्टेमिंग कहा जाता है और अलग-अलग स्टेमर्स मौजूद होते हैं जो गति, आक्रामकता और इसी तरह से भिन्न होते हैं। इसलिए हम प्रत्येक दस्तावेज़ को बिना रोक-टोक शब्दों की सूची में बदल देते हैं। इसके अलावा, हम सभी विराम चिह्न को छोड़ देते हैं।

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]

तो शब्दों का यह थैला हमारी मदद कैसे करेगा? कल्पना कीजिए कि हम 3 बैग है: [a, b, c], [a, c, a]और [b, c, d]। हम उन्हें आधार में वैक्टर में बदल सकते हैं[a, b, c, d] । इसलिए हम वैक्टर के साथ अंत: [1, 1, 1, 0], [2, 0, 1, 0]और [0, 1, 1, 1]। इसी तरह की बात हमारे दस्तावेजों के साथ है (केवल वैक्टर लंबे समय तक चलेगा)। अब हम देखते हैं कि हमने बहुत सारे शब्द हटा दिए हैं और अन्य को भी हटा दिया है ताकि वैक्टर के आयाम कम हो सकें। यहाँ सिर्फ दिलचस्प अवलोकन है। लंबे दस्तावेजों में छोटे की तुलना में अधिक सकारात्मक तत्व होंगे, यही कारण है कि वेक्टर को सामान्य करना अच्छा है। इसे टर्म फ़्रीक्वेंसी टीएफ कहा जाता है, लोगों ने अतिरिक्त जानकारी का भी इस्तेमाल किया कि शब्द को अन्य दस्तावेजों में कितनी बार उपयोग किया जाता है - उलटा दस्तावेज़ आवृत्ति आईडीएफ। साथ में हमारे पास एक मीट्रिक है TF-IDF है जिसमें कुछ फ्लेवर्स हैं। यह sklearn में एक लाइन के साथ प्राप्त किया जा सकता है :-)

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)

वास्तव में वेक्टराइज़र बहुत सारे काम करने की अनुमति देता है जैसे स्टॉप शब्द निकालना और लोअरस्किंग करना। मैंने उन्हें केवल एक अलग चरण में किया है क्योंकि स्केलेरोन के पास गैर-अंग्रेजी स्टॉपवार्ड नहीं है, लेकिन nltk है।

इसलिए हमारे पास सभी वैक्टर की गणना है। अंतिम चरण यह पता लगाना है कि कौन सा पिछले एक के समान है। इसे प्राप्त करने के विभिन्न तरीके हैं, उनमें से एक यूक्लिडियन दूरी है जो यहां चर्चा किए गए कारण के लिए इतना महान नहीं है । एक अन्य दृष्टिकोण कोसाइन समानता है । हम सभी दस्तावेजों को पुन: व्यवस्थित करते हैं और दस्तावेज़ और पिछले एक के बीच कोसाइन समानता की गणना करते हैं:

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

अब न्यूनतम में सर्वश्रेष्ठ दस्तावेज और उसके स्कोर के बारे में जानकारी होगी।

Question 6

इससे आपको मदद मिलनी चाहिए।

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

और उत्पादन होगा:

[[ 0.34949812  0.81649658  1.        ]]

Question 7

यहां एक फ़ंक्शन है जो प्रशिक्षण डेटा के खिलाफ आपके परीक्षण डेटा की तुलना करता है, प्रशिक्षण डेटा के साथ फिट किए गए Tf-Idf ट्रांसफार्मर के साथ। लाभ यह है कि आप एन निकटतम तत्वों को खोजने के लिए जल्दी से धुरी या समूह बना सकते हैं, और यह कि गणना मैट्रिक्स-वार है।

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