मैं सेब (फल) के बारे में ट्वीट से एप्पल (इंक) के बारे में ट्वीट को अलग करने के लिए एक मॉडल कैसे बना सकता हूं?


85

"सेब" के बारे में 50 ट्वीट्स के लिए नीचे देखें। मैंने Apple इंक के बारे में सकारात्मक मिलानों को लेबल किया है। उन्हें नीचे 1 के रूप में चिह्नित किया गया है।

यहाँ कुछ पंक्तियाँ हैं:

1|“@chrisgilmer: Apple targets big business with new iOS 7 features http://bit.ly/15F9JeF ”. Finally.. A corp iTunes account!
0|“@Zach_Paull: When did green skittles change from lime to green apple? #notafan” @Skittles
1|@dtfcdvEric: @MaroneyFan11 apple inc is searching for people to help and tryout all their upcoming tablet within our own net page No.
0|@STFUTimothy have you tried apple pie shine?
1|#SuryaRay #India Microsoft to bring Xbox and PC games to Apple, Android phones: Report: Microsoft Corp... http://dlvr.it/3YvbQx  @SuryaRay

यहाँ कुल डेटा सेट है: http://pastebin.com/eJuEb4eB

मुझे एक मॉडल बनाने की ज़रूरत है जो "ऐप्पल" (इंक) को वर्गीकृत करता है। शेष में से।

मैं मशीन लर्निंग के सामान्य अवलोकन की तलाश में नहीं हूं, बल्कि मैं कोड ( पायथन पसंदीदा) में वास्तविक मॉडल की तलाश कर रहा हूं ।


18
आप मूल रूप से यह चाहते हैं: en.wikipedia.org/wiki/Bayesian_spam_filtering
eddi

1
आप अपने डेटा को लेबल करते हैं, लेकिन उस पैमाने पर लाइब्रेरी चाहते हैं। क्या यह देखरेख या अनुपयोगी है?
दान २

1
एड्डी, धन्यवाद, टिप्पणी के लिए। मेल फ़िल्टरिंग ईमेल देखें वास्तव में मेरे दिमाग में कुछ क्लिक करने में मदद मिली। मैं वास्तविक जीवन का उदाहरण देख पा रहा था कि मैं क्या करने की कोशिश कर रहा था, बस अलग तरह से लागू किया गया।
सल

5
नामित एंटिटी मान्यता: nlp.stanford.edu/software/CRF-NER.shtml
नील मैकगिन

1
मोहक @NeilMcGuigan। मैंने उनके डेमो ( nlp.stanford.edu:8080/ner/process ) पर कुछ पाठों में चिपकाया और विभिन्न मॉडलों ने शब्दों को कैसे वर्गीकृत किया, इससे मैं प्रभावित हुआ।
रयान

जवाबों:


39

मैं इसे निम्नानुसार करूंगा:

  1. शब्दों में वाक्य को विभाजित करें, उन्हें सामान्य करें, एक शब्दकोश बनाएं
  2. प्रत्येक शब्द के साथ, कंपनी के बारे में ट्वीट्स में कितनी बार स्टोर किया और फल के बारे में ट्वीट में वे कितनी बार दिखाई दिए - इन ट्वीट्स की एक मानव द्वारा पुष्टि की जानी चाहिए
  3. जब कोई नया ट्वीट आता है, तो शब्दकोश में ट्वीट में हर शब्द को ढूंढें, एक भारित स्कोर की गणना करें - कंपनी के संबंध में अक्सर उपयोग किए जाने वाले शब्दों को एक उच्च कंपनी स्कोर मिलेगा, और इसके विपरीत; कंपनी या फल दोनों के साथ उपयोग किए जाने वाले शब्द शायद ही कभी इस्तेमाल किए गए हों, लेकिन उनमें बहुत अधिक अंक नहीं होंगे।

2
इस पर आपके उत्तर के लिए धन्यवाद। ऊपर एक टिप्पणी के साथ आपका जवाब वास्तव में मुझे एक समाधान की ओर ले जाने में मदद करता है। क्या आप इस समाधान को सुधारने में मेरी मदद कर सकते हैं?
सल

10
यह बायेसियन वर्गीकरण का एक अनौपचारिक विवरण है।
संन्यासी

1
मैं "
बेयूसियन

73

आप जिस चीज की तलाश कर रहे हैं उसे नामांकित पहचान मान्यता कहा जाता है । यह एक सांख्यिकीय तकनीक है जो (आमतौर पर) नामांकित संस्थाओं को खोजने के लिए सशर्त यादृच्छिक फ़ील्ड्स का उपयोग करती है, जो नामित संस्थाओं के बारे में सीखने के लिए प्रशिक्षित होने के आधार पर किया गया है।

अनिवार्य रूप से, यह शब्द की सामग्री और संदर्भ को देखता है, (कुछ शब्दों को पीछे और आगे की ओर देखता है ), इस संभावना का अनुमान लगाने के लिए कि शब्द एक नामित इकाई है।

अच्छा सॉफ्टवेयर शब्दों की अन्य विशेषताओं को देख सकता है, जैसे कि उनकी लंबाई या आकृति (जैसे "Vcv" यदि यह "स्वर-व्यंजन-स्वर" से शुरू होता है)

एक बहुत अच्छी लाइब्रेरी (GPL) स्टैनफोर्ड की NER है

यहाँ डेमो है: http://nlp.stanford.edu:8080/ner/

कुछ नमूना पाठ आज़माने के लिए:

मैं Apple के मुख्यालय में एक सेब खा रहा था और मैंने कोल्डप्ले आदमी की बेटी Apple मार्टिन के बारे में सोचा

(3 वर्ग और 4 वर्ग के क्लासीफायर इसे सही पाते हैं)


5
यह वाकई दिलचस्प था। क्या इसके लिए कोड देखना संभव है english.conll.4class.distsim.crf.ser.gz? मैं यह देखना पसंद करूंगा कि कोई इस तरह से कुछ कैसे बनाता है।
रयान

एनईआर के लिए कोड खुला स्रोत है, लेकिन कॉनएलएल सम्मेलनों में उन्होंने जो डेटा इस्तेमाल किया है वह नहीं है। हालांकि, आप एनआईईएसटी पर रॉयटर्स कॉर्पस ऑनलाइन पा सकते हैं।
नील मैकगिगन

31

मेरे पास एक अर्ध-कामकाजी प्रणाली है जो इस समस्या को हल करती है, स्किटिट-लर्न का उपयोग करके खुली हुई है, ब्लॉग पोस्टों की एक श्रृंखला के साथ जो मैं कर रहा हूं उसका वर्णन करता हूं। मैं जिस समस्या से जूझ रहा हूं वह शब्द-बोध विमुक्ति (कई शब्द अर्थ विकल्पों में से एक को चुनना ) है, जो नामांकित व्यक्ति की मान्यता के समान नहीं है। मेरा मूल दृष्टिकोण मौजूदा समाधानों के साथ कुछ हद तक प्रतिस्पर्धी है और (महत्वपूर्ण रूप से) अनुकूलन योग्य है।

कुछ मौजूदा वाणिज्यिक एनईआर उपकरण (ओपनकैलाइस, डीबीपीडिया स्पॉटलाइट, और अल्केमीएपीआई) हैं जो आपको एक अच्छा पर्याप्त वाणिज्यिक परिणाम दे सकते हैं - पहले ये प्रयास करें!

मैंने इनमें से कुछ का उपयोग एक ग्राहक परियोजना के लिए किया था (मैं लंदन में एनएलपी / एमएल का उपयोग करके परामर्श करता हूं), लेकिन मैं उनके रिकॉल ( सटीक और याद ) से खुश नहीं था । मूल रूप से वे सटीक हो सकते हैं (जब वे कहते हैं "यह ऐप्पल इंक है" वे आम तौर पर सही होते हैं), लेकिन कम याद के साथ (वे शायद ही कभी कहते हैं "यह ऐप्पल इंक है" भले ही मानव के लिए ट्वीट स्पष्ट रूप से ऐप्पल इंक के बारे में है)। मुझे लगा कि ट्वीट्स के अनुरूप एक खुला स्रोत संस्करण बनाने के लिए यह बौद्धिक रूप से दिलचस्प अभ्यास होगा। यहाँ वर्तमान कोड है: https://github.com/ianozsvald/social_media_brand_disambiguator

मैं ध्यान देता हूँ - जब आप पहले से ही अपना नाम रखते हैं , तो मैं इस दृष्टिकोण के साथ सामान्यीकृत शब्द-बोध की समस्या को हल करने की कोशिश नहीं कर रहा हूँ, बस ब्रांड की छूट (कंपनियों, लोगों, आदि)। इसलिए मेरा मानना ​​है कि यह सीधा तरीका काम करेगा।

मैंने इसे छह सप्ताह पहले शुरू किया था, और यह स्किकिट-लर्न का उपयोग करके पायथन 2.7 में लिखा गया है। यह एक बहुत ही बुनियादी दृष्टिकोण का उपयोग करता है। मैं एक द्विआधारी गिनती वेक्टराइज़र का उपयोग करके वेक्टर करता हूं (मैं केवल गिनती करता हूं कि कोई शब्द दिखाई देता है, न कि कितनी बार) 1-3 के साथ  एन-ग्राम के साथ । मैं TF-IDF के साथ स्केल नहीं करता (TF-IDF तब अच्छा होता है जब आपके पास वैरिएबल डॉक्यूमेंट की लंबाई होती है; मेरे लिए ट्वीट केवल एक या दो वाक्य होते हैं, और मेरे परीक्षण के परिणाम TF-IDF के साथ सुधार नहीं दिखाते हैं)।

मैं मूल टोकन का उपयोग करता हूं जो बहुत बुनियादी है लेकिन आश्चर्यजनक रूप से उपयोगी है। यह @ # को अनदेखा करता है (इसलिए आप कुछ संदर्भ खो देते हैं) और निश्चित रूप से एक URL का विस्तार नहीं करता है। मैं तो उपयोग कर प्रशिक्षित करता हूं लॉजिस्टिक रिग्रेशन , और ऐसा लगता है कि यह समस्या कुछ हद तक अलग-अलग है (एक वर्ग के लिए बहुत शब्द दूसरे के लिए मौजूद नहीं हैं)। वर्तमान में मैं किसी भी प्रकार की तंगी / सफाई से बच रहा हूँ (मैं सरलतम संभावित बात यह काम कर रहा हूँ)।

कोड में एक पूर्ण README है, और आपको अपने ट्वीट को अपेक्षाकृत आसानी से निगलना चाहिए और फिर परीक्षण के लिए मेरे सुझावों का पालन करना चाहिए।

यह Apple के लिए काम करता है क्योंकि लोग Apple कंप्यूटर नहीं खाते या पीते हैं, न ही हम फल के साथ टाइप या खेलते हैं, इसलिए शब्द आसानी से एक श्रेणी या दूसरे में विभाजित हो जाते हैं। टीवी शो के लिए #definance (जहाँ लोग अरब स्प्रिंग, क्रिकेट मैच, परीक्षा संशोधन और एक संगीत बैंड के संबंध में भी लोग #definance का उपयोग करते हैं) पर विचार करते समय यह स्थिति पकड़ में नहीं आ सकती है। चतुर दृष्टिकोण यहाँ अच्छी तरह से आवश्यक हो सकता है।

मेरे पास इस परियोजना का वर्णन करने वाली एक श्रृंखला है, जिसमें मैंने एक घंटे की प्रस्तुति भी शामिल है, जो मैंने BrightonPython usergroup पर दी थी (जो कि DataScienceLondon में 140 लोगों के लिए एक छोटी प्रस्तुति में बदल गई थी)।

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

यहाँ एक संभव एल्गोरिथ्म दृष्टिकोण का उपयोग कर सीख रहा है:

  • एक द्विआधारी CountVectorizer का उपयोग करें (मुझे नहीं लगता कि छोटे संदेशों में शब्द-गणना बहुत जानकारी जोड़ते हैं क्योंकि अधिकांश शब्द केवल एक बार होते हैं)
  • निर्णय ट्री क्लासिफायरियर से शुरू करें। इसका व्याख्यात्मक प्रदर्शन होगा ( उदाहरण के लिए निर्णय ट्री के साथ ओवरफिटिंग देखें )।
  • लॉजिस्टिक रिग्रेशन पर जाएं
  • सहपाठियों द्वारा उत्पन्न त्रुटियों की जाँच करें (DecisionTree के निर्यातित आउटपुट को पढ़ें या LogisticRegression में गुणांक को देखें, सदिशाइज़र के माध्यम से गलत-वर्गीकृत ट्वीट पर काम करें, यह देखने के लिए कि शब्दों के अंतर्निहित थैले का प्रतिनिधित्व क्या है - जैसे कि वहाँ से कम टोकन होंगे आपने कच्चे ट्वीट के साथ शुरुआत की - क्या वर्गीकरण के लिए पर्याप्त हैं?)
  • इस दृष्टिकोण के काम किए गए संस्करण के लिए मेरा उदाहरण कोड https://github.com/ianozsvald/social_media_brand_disambiguator/blob/master/learn1.py पर देखें

विचार करने के लिए बातें:

  • आपको एक बड़े डेटासेट की आवश्यकता है। मैं २००० लेबल वाले ट्वीट का उपयोग कर रहा हूँ (इसमें मुझे पाँच घंटे लगे), और एक न्यूनतम के रूप में आप> १०० प्रति वर्ग के साथ एक संतुलित सेट चाहते हैं (नीचे ओवरफिटिंग नोट देखें)
  • टोकन (# स्किटिट-लर्न के साथ बहुत आसान) को टोकन में # @ रखने के लिए सुधार करें, और हो सकता है कि एक पूंजी-ब्रांड डिटेक्टर जोड़ें (जैसा कि उपयोगकर्ता @ user2425429 नोट)
  • जब चीजें कठिन हो जाएं तो एक गैर-रैखिक क्लासिफायरियर (जैसे @ ओइज़ के सुझाव ऊपर) पर विचार करें। व्यक्तिगत रूप से मुझे लीनियरएसवीसी मिला है जो लॉजिस्टिक रिग्रेशन से भी बदतर है (लेकिन यह उस उच्च-आयामी सुविधा स्थान के कारण हो सकता है जिसे मैंने अभी तक कम किया है)।
  • भाषण टैगर का एक ट्वीट-विशिष्ट हिस्सा (मेरी विनम्र राय में स्टैंडफोर्ड के रूप में @ निल का सुझाव नहीं है - यह मेरे अनुभव में खराब ट्विटर व्याकरण पर खराब प्रदर्शन करता है)
  • एक बार जब आपके पास बहुत सारे टोकन होते हैं, तो आप शायद कुछ आयामी कमी करना चाहते हैं (मैंने अभी तक यह कोशिश नहीं की है - लॉजिस्टिक रीजनरेशन एल 1 एल 2 दंड पर मेरा ब्लॉग पोस्ट देखें)

पुन। overfitting। 2000 आइटम्स के साथ मेरे डेटासेट में मेरे पास 'ऐप्पल' ट्वीट के ट्विटर से 10 मिनट का स्नैपशॉट है। ट्वीट्स के बारे में 2/3 एप्पल इंक के लिए हैं, अन्य सेब के उपयोग के लिए 1/3 हैं। मैं प्रत्येक वर्ग के एक संतुलित उपसमूह (लगभग 584 पंक्तियाँ जो मुझे लगता है) को खींचता है और प्रशिक्षण के लिए पांच गुना क्रॉस सत्यापन करता है।

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


मुझे आपके कोड को देखने और डुप्लिकेट / अनुकरण / शिक्षित करने की कोशिश करने का आनंद नहीं मिला है, लेकिन मैं आपको इनाम के पूरे 50 अवसर का पुरस्कार नहीं देने के लिए माफी चाहता हूं। मैं सप्ताहांत में एसओ से दूर था और इसे पुरस्कृत करने की समय सीमा से चूक गया। शुक्र है कि एसओ समुदाय ने कदम बढ़ाया और आपको 25 पुरस्कार देने के लिए फिट देखा।
रयान

1
कोई समस्या नहीं :-) कोड, README और ब्लॉग पोस्ट आपको मेरे दृष्टिकोण के बारे में एक विचार देना चाहिए। यह जानबूझकर सरल है, लेकिन लगता है काम ठीक है।
इयान ओजस्वाल्ड

12

आप निम्न कार्य कर सकते हैं:

  1. फल और कंपनी से संबंधित ट्वीट में उनकी गणना की जाने वाली शब्दों की एक तानाशाही बनाएं। यह कुछ नमूना ट्वीट्स को खिलाकर प्राप्त किया जा सकता है, जिनके झुकाव को हम जानते हैं।

  2. पर्याप्त पिछले डेटा का उपयोग करके, हम सेब इंक के बारे में ट्वीट में होने वाले एक शब्द की संभावना का पता लगा सकते हैं।

  3. पूरे ट्वीट की संभावना पाने के लिए शब्दों की व्यक्तिगत संभावनाओं को गुणा करें।

एक सरल उदाहरण:

p_f = फलों के ट्वीट की संभावना।

p_w_f = फलों के कलरव में होने वाले शब्द की संभावना।

p_t_f = ट्वीट में सभी शब्दों की संयुक्त संभावना एक फल वाला ट्वीट = p_w1_f * p_w2_f * ...

p_f_t = किसी विशेष ट्वीट के फल की संभावना।

p_c, p_w_c, p_t_c, p_c_t कंपनी के लिए संबंधित मूल्य हैं।

मूल्य 1 के एक लैपलैसियन चिकनी को नए शब्दों की शून्य आवृत्ति की समस्या को खत्म करने के लिए जोड़ा जाता है जो हमारे डेटाबेस में नहीं हैं।

old_tweets = {'apple pie sweet potatoe cake baby https://vine.co/v/hzBaWVA3IE3': '0', ...}
known_words = {}
total_company_tweets = total_fruit_tweets =total_company_words = total_fruit_words = 0

for tweet in old_tweets:
    company = old_tweets[tweet]
    for word in tweet.lower().split(" "):
        if not word in known_words:
            known_words[word] = {"company":0, "fruit":0 }
        if company == "1":
            known_words[word]["company"] += 1
            total_company_words += 1
        else:
            known_words[word]["fruit"] += 1
            total_fruit_words += 1

    if company == "1":
        total_company_tweets += 1
    else:
        total_fruit_tweets += 1
total_tweets = len(old_tweets)

def predict_tweet(new_tweet,K=1):
    p_f = (total_fruit_tweets+K)/(total_tweets+K*2)
    p_c = (total_company_tweets+K)/(total_tweets+K*2)
    new_words = new_tweet.lower().split(" ")

    p_t_f = p_t_c = 1
    for word in new_words:
        try:
            wordFound = known_words[word]
        except KeyError:
            wordFound = {'fruit':0,'company':0}
        p_w_f = (wordFound['fruit']+K)/(total_fruit_words+K*(len(known_words)))
        p_w_c = (wordFound['company']+K)/(total_company_words+K*(len(known_words)))
    p_t_f *= p_w_f
    p_t_c *= p_w_c

    #Applying bayes rule
    p_f_t = p_f * p_t_f/(p_t_f*p_f + p_t_c*p_c)
    p_c_t = p_c * p_t_c/(p_t_f*p_f + p_t_c*p_c)
    if p_c_t > p_f_t:
        return "Company"
    return "Fruit"

9

यदि आपके पास बाहर की लाइब्रेरी का उपयोग करने का कोई मुद्दा नहीं है, तो मैं स्कोरिट-लर्न की सिफारिश करूंगा क्योंकि यह संभव है कि यह आपके द्वारा कोडित की गई चीज़ों से बेहतर और तेज़ हो सकता है। मैं बस कुछ इस तरह से करूँगा:

अपने कॉर्पस का निर्माण करें। मैंने सूची को स्पष्टता के लिए समझ लिया था, लेकिन आपका डेटा कैसे संग्रहीत किया जाता है, इसके आधार पर आपको अलग-अलग काम करने की आवश्यकता हो सकती है:

def corpus_builder(apple_inc_tweets, apple_fruit_tweets):
    corpus = [tweet for tweet in apple_inc_tweets] + [tweet for tweet in apple_fruit_tweets]
    labels = [1 for x in xrange(len(apple_inc_tweets))] + [0 for x in xrange(len(apple_fruit_tweets))]
    return (corpus, labels)

महत्वपूर्ण बात यह है कि आप दो सूचियों के साथ समाप्त होते हैं जो इस तरह दिखती हैं:

([['apple inc tweet i love ios and iphones'], ['apple iphones are great'], ['apple fruit tweet i love pie'], ['apple pie is great']], [1, 1, 0, 0])

[1, 1, 0, 0] सकारात्मक और नकारात्मक लेबल का प्रतिनिधित्व करते हैं।

फिर, आप एक पाइपलाइन बनाएँ! पाइपलाइन एक स्किकिट-लर्न क्लास है जो टेक्स्ट प्रोसेसिंग के चरणों को एक साथ जोड़ना आसान बनाता है इसलिए आपको केवल एक वस्तु को कॉल करना होगा जब प्रशिक्षण / भविष्यवाणी करना होगा:

def train(corpus, labels)
    pipe = Pipeline([('vect', CountVectorizer(ngram_range=(1, 3), stop_words='english')),
                        ('tfidf', TfidfTransformer(norm='l2')),
                        ('clf', LinearSVC()),])
    pipe.fit_transform(corpus, labels)
    return pipe

पाइपलाइन के अंदर तीन प्रसंस्करण चरण हैं। CountVectorizer शब्दों को टोकन देता है, उन्हें विभाजित करता है, उन्हें गिनता है, और डेटा को विरल मैट्रिक्स में बदलता है। TfidfTransformer वैकल्पिक है, और आप सटीकता रेटिंग के आधार पर इसे हटाना चाह सकते हैं (क्रॉस सत्यापन परीक्षण कर रहे हैं और सर्वोत्तम मापदंडों के लिए एक ग्रिड खोज इसमें शामिल है, इसलिए मैं यहां नहीं मिलेगा)। LinearSVC एक मानक पाठ वर्गीकरण एल्गोरिथ्म है।

अंत में, आप ट्वीट की श्रेणी की भविष्यवाणी करते हैं:

def predict(pipe, tweet):
    prediction = pipe.predict([tweet])
    return prediction

फिर से, ट्वीट को एक सूची में होना चाहिए, इसलिए मैंने माना कि यह एक स्ट्रिंग के रूप में फ़ंक्शन में प्रवेश कर रहा है।

उन सभी को एक कक्षा में रखें या जो भी हो, और आप कर रहे हैं। कम से कम, इस बहुत बुनियादी उदाहरण के साथ।

मैंने इस कोड का परीक्षण नहीं किया है, तो यह काम नहीं कर सकता है यदि आप सिर्फ कॉपी-पेस्ट करते हैं, लेकिन यदि आप scikit का उपयोग करना चाहते हैं, तो आपको यह पता लगाना चाहिए कि आपको कहां से शुरू करना चाहिए।

EDIT: चरणों को अधिक विस्तार से समझाने की कोशिश की।


6

एक निर्णय पेड़ का उपयोग करना इस समस्या के लिए काफी अच्छा काम करता है। कम से कम यह मेरी चुनी हुई विशेषताओं के साथ एक अनुभवहीन बेयस क्लासिफायर की तुलना में अधिक सटीकता पैदा करता है।

यदि आप कुछ संभावनाओं के साथ खेलना चाहते हैं, तो आप निम्नलिखित कोड का उपयोग कर सकते हैं, जिसे स्थापित करने के लिए nltk की आवश्यकता होती है। Nltk पुस्तक भी ऑनलाइन उपलब्ध है, इसलिए आप इस बारे में थोड़ा पढ़ना चाहते हैं कि यह वास्तव में कैसे काम करता है: http://nltk.googlecode.com/svn/trunk/doc/book/ch06.html

#coding: utf-8
import nltk
import random
import re

def get_split_sets():
    structured_dataset = get_dataset()
    train_set = set(random.sample(structured_dataset, int(len(structured_dataset) * 0.7)))
    test_set = [x for x in structured_dataset if x not in train_set]

    train_set = [(tweet_features(x[1]), x[0]) for x in train_set]
    test_set = [(tweet_features(x[1]), x[0]) for x in test_set]
    return (train_set, test_set)

def check_accurracy(times=5):
    s = 0
    for _ in xrange(times):
        train_set, test_set = get_split_sets()
        c = nltk.classify.DecisionTreeClassifier.train(train_set)
        # Uncomment to use a naive bayes classifier instead
        #c = nltk.classify.NaiveBayesClassifier.train(train_set)
        s += nltk.classify.accuracy(c, test_set)

    return s / times


def remove_urls(tweet):
    tweet = re.sub(r'http:\/\/[^ ]+', "", tweet)
    tweet = re.sub(r'pic.twitter.com/[^ ]+', "", tweet)
    return tweet

def tweet_features(tweet):
    words = [x for x in nltk.tokenize.wordpunct_tokenize(remove_urls(tweet.lower())) if x.isalpha()]
    features = dict()
    for bigram in nltk.bigrams(words):
        features["hasBigram(%s)" % ",".join(bigram)] = True
    for trigram in nltk.trigrams(words):
        features["hasTrigram(%s)" % ",".join(trigram)] = True  
    return features

def get_dataset():
    dataset = """copy dataset in here
"""
    structured_dataset = [('fruit' if x[0] == '0' else 'company', x[2:]) for x in dataset.splitlines()]
    return structured_dataset

if __name__ == '__main__':
    print check_accurracy()

1
यह कैसे काम करता है? मुझे आपके कोड में आपकी "चुनी हुई सुविधाएँ" नहीं दिख रही हैं। क्या यह स्वचालित रूप से प्रशिक्षण सेट के आधार पर सुविधाओं का चयन करता है? या यह dict()कहीं और संग्रहीत है? मुझे लगता है कि अगर किसी का प्रशिक्षण सेट काफी बड़ा है, तो क्या एक कंप्यूटर को स्वयं सुविधाओं का पता लगाने में सक्षम नहीं होना चाहिए? (unsupervised?)
Ryan

2
विशेषताएँ tweet_features फ़ंक्शन का उपयोग करके निकाली गई हैं। यह मूल रूप से ट्वीट से उरोजों को हटाता है, और फिर एक फीचर को तानाशाही बनाता है जिसकी प्रविष्टियां कुछ इस तरह पढ़ी जाती हैं जैसे 'hasBigram (फू, बार)' = True।
पॉल डबल्स

1
तो 'hasBigram(foo,bar)' = Trueकहाँ ट्वीट स्ट्रिंग शामिल हैं foo bar? इसलिए यह प्रत्येक ट्वीट के लिए बिग्रेड और ट्रिगर्स बनाता है और इसे सकारात्मक सुविधा में चिह्नित करता है dict()? इसलिए ट्वीट को देखते हुए "alpha beta gamma delta", यह dict () के लिए Bigrams का निर्माण करेगा alpha,beta; beta,gamma; and gamma,delta;और के लिए Trigrams alpha,beta,gammaऔर beta,gamma,delta? और दिए गए पॉजिटिव और नेगेटिव बाय और ट्राई ग्राम में से डिसीट्री या बाइस क्लासिफायर अपने जादू कर सकते हैं?
रयान

2
बिल्कुल सही। बेय्स क्लासिफायर का उपयोग करते समय आप इस पर "show_most_informative_features ()" कॉल करके सबसे उपयोगी सुविधाएं भी प्राप्त कर सकते हैं।
पॉल डब

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

5

इस प्रकार टिप्पणी के लिए धन्यवाद। यहाँ एक कार्यशील समाधान है जिसे मैंने PHP के साथ तैयार किया है। मैं अभी भी दूसरों से इस एक ही समाधान के लिए एक अधिक एल्गोरिदम दृष्टिकोण सुनने में दिलचस्पी होगी।

<?php

// Confusion Matrix Init
$tp = 0;
$fp = 0;
$fn = 0;
$tn = 0;
$arrFP = array();
$arrFN = array();

// Load All Tweets to string
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'http://pastebin.com/raw.php?i=m6pP8ctM');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$strCorpus = curl_exec($ch);
curl_close($ch);

// Load Tweets as Array
$arrCorpus = explode("\n", $strCorpus);
foreach ($arrCorpus as $k => $v) {
    // init
    $blnActualClass = substr($v,0,1);
    $strTweet = trim(substr($v,2));

    // Score Tweet
    $intScore = score($strTweet);

    // Build Confusion Matrix and Log False Positives & Negatives for Review
    if ($intScore > 0) {
        if ($blnActualClass == 1) {
            // True Positive
            $tp++;
        } else {
            // False Positive
            $fp++;
            $arrFP[] = $strTweet;
        }
    } else {
        if ($blnActualClass == 1) {
            // False Negative
            $fn++;
            $arrFN[] = $strTweet;
        } else {
            // True Negative
            $tn++;
        }
    }
}

// Confusion Matrix and Logging
echo "
           Predicted
            1     0
Actual 1   $tp     $fp
Actual 0    $fn    $tn

";

if (count($arrFP) > 0) {
    echo "\n\nFalse Positives\n";
    foreach ($arrFP as $strTweet) {
        echo "$strTweet\n";
    }
}

if (count($arrFN) > 0) {
    echo "\n\nFalse Negatives\n";
    foreach ($arrFN as $strTweet) {
        echo "$strTweet\n";
    }
}

function LoadDictionaryArray() {
    $strDictionary = <<<EOD
10|iTunes
10|ios 7
10|ios7
10|iPhone
10|apple inc
10|apple corp
10|apple.com
10|MacBook
10|desk top
10|desktop
1|config
1|facebook
1|snapchat
1|intel
1|investor
1|news
1|labs
1|gadget
1|apple store
1|microsoft
1|android
1|bonds
1|Corp.tax
1|macs
-1|pie
-1|clientes
-1|green apple
-1|banana
-10|apple pie
EOD;

    $arrDictionary = explode("\n", $strDictionary);
    foreach ($arrDictionary as $k => $v) {
        $arr = explode('|', $v);
        $arrDictionary[$k] = array('value' => $arr[0], 'term' => strtolower(trim($arr[1])));
    }
    return $arrDictionary;
}

function score($str) {
    $str = strtolower($str);
    $intScore = 0;
    foreach (LoadDictionaryArray() as $arrDictionaryItem) {
        if (strpos($str,$arrDictionaryItem['term']) !== false) {
            $intScore += $arrDictionaryItem['value'];
        }
    }
    return $intScore;
}
?>

उपरोक्त आउटपुट:

           Predicted
            1     0
Actual 1   31     1
Actual 0    1    17


False Positives
1|Royals apple #ASGame @mlb @ News Corp Building http://instagram.com/p/bBzzgMrrIV/


False Negatives
-1|RT @MaxFreixenet: Apple no tiene clientes. Tiene FANS// error.... PAGAS por productos y apps, ergo: ERES CLIENTE.

4

आपके द्वारा दिए गए सभी उदाहरणों में, Apple (inc) को या तो A pple या Apple inc के रूप में संदर्भित किया गया था , इसलिए संभव तरीका खोजा जा सकता है:

  • Apple में एक पूंजी "A"

  • सेब के बाद एक "इंक"

  • शब्द / वाक्यांश जैसे "OS", "ऑपरेटिंग सिस्टम", "Mac", "iPhone", ...

  • या उनमें से एक संयोजन


1
फ़ंक्शन में मैंने कैपिटल अक्षरों को फ़िल्टर करने के लिए एक स्ट्रेटोलॉवर किया। थोड़ा कच्चा, लेकिन यह काम कर गया।
सल

@ मुझे उम्मीद नहीं थी कि यह बहुत उपयोगी होगा, लेकिन अगर आपके पास समय सीमा है, तो ...
user2425429

4

सशर्त रैंडम फ़ील्ड के आधार पर उत्तरों को सरल बनाने के लिए ... संदर्भ यहाँ बहुत बड़ा है। आप उन ट्वीट्स में से बाहर निकालना चाहेंगे जो स्पष्ट रूप से ऐप्पल कंपनी बनाम सेब को फल दिखाते हैं। मुझे यहां उन विशेषताओं की एक सूची बताएं, जो आपके लिए शुरू करने के लिए उपयोगी हो सकती हैं। अधिक जानकारी के लिए संज्ञा वाक्यांश को देखें, और BIO लेबल नामक कुछ। देखें ( http://www.cis.upenn.edu/~pereira/papers/crf.pdf )

आसपास के शब्द: पिछले शब्द और अगले शब्द के लिए एक फीचर वेक्टर बनाएँ, या यदि आप अधिक सुविधाएँ चाहते हैं तो शायद पिछले 2 और अगले 2 शब्द। आप मॉडल में बहुत सारे शब्द नहीं चाहते हैं या यह डेटा से बहुत अच्छे से मेल नहीं खाएगा। प्राकृतिक भाषा प्रसंस्करण में, आप इसे यथासंभव सामान्य रखना चाहते हैं।

आसपास के शब्दों से प्राप्त करने के लिए अन्य विशेषताओं में निम्नलिखित शामिल हैं:

चाहे पहला चरित्र एक पूंजी हो

चाहे शब्द में अंतिम चरित्र एक अवधि है

शब्द के बोलने का हिस्सा (भाषण टैगिंग का हिस्सा देखें)

शब्द का पाठ

मैं इसकी सलाह नहीं देता, लेकिन विशेष रूप से Apple के लिए और अधिक उदाहरण देने के लिए:

WordIs (Apple)

NextWordIs (इंक।)

तुम समझ गए। एक अनुक्रम का वर्णन करने के रूप में नामित इकाई मान्यता के बारे में सोचें, और फिर कुछ गणित का उपयोग करके कंप्यूटर को बताएं कि कैसे गणना करें।

ध्यान रखें कि प्राकृतिक भाषा प्रसंस्करण एक पाइपलाइन आधारित प्रणाली है। आमतौर पर, आप वाक्यों को तोड़ते हैं, टोकेलाइजेशन में जाते हैं, फिर भाषण टैगिंग या यहां तक ​​कि निर्भरता पार्सिंग का हिस्सा भी करते हैं।

यह सब आपको उन सुविधाओं की एक सूची प्राप्त करने के लिए है जिन्हें आप अपने मॉडल में उपयोग कर सकते हैं कि आप क्या देख रहे हैं।


3

पायथन नामक प्राकृतिक भाषा पाठ को संसाधित करने के लिए वास्तव में एक अच्छा पुस्तकालय है nltk। आपको इसे देखना चाहिए।

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


1
धन्यवाद मितरन। मैं मूल पोस्टर नहीं हूं, लेकिन मुझे उत्तर में भी दिलचस्पी है। इनाम के लिए मैं कुछ कोड (यहां तक ​​कि उपयोग कर रहा हूं) की तलाश कर रहा हूं nltkजो मुझे "हेल्लो वर्ल्ड" मशीन सीखने के कार्य के साथ सही दिशा में शुरू करने में मदद कर सकता है। सेब (इंक) बनाम सेब (फल) एक आदर्श काम लगता है।
रयान

3

LibShortText का उपयोग करें । इस पायथन उपयोगिता को पहले ही छोटे पाठ वर्गीकरण कार्यों के लिए काम करने के लिए तैयार किया गया है, और यह अच्छी तरह से काम करता है। झंडे का सबसे अच्छा संयोजन लेने के लिए आपको अधिकतम एक लूप लिखना होगा। मैंने इसका उपयोग ईमेलों में भाषण एक्ट वर्गीकरण का पर्यवेक्षण करने के लिए किया था और परिणाम 95-97% तक सटीक थे (5 गुना क्रॉस सत्यापन के दौरान!)।

और यह LIBSVM और LIBLINEAR के निर्माताओं से आता है जिनके समर्थन वेक्टर मशीन (SVM) के कार्यान्वयन का उपयोग स्केलेर और क्रैन में किया जाता है, इसलिए आपको यथोचित आश्वासन दिया जा सकता है कि उनका कार्यान्वयन छोटी गाड़ी नहीं है।


2

सेब (फल) से Apple Inc (कंपनी) को अलग करने के लिए AI फ़िल्टर बनाएं । चूंकि ये ट्वीट हैं, 140 क्षेत्रों के वेक्टर के साथ अपने प्रशिक्षण सेट को परिभाषित करें, प्रत्येक क्षेत्र को स्थिति X (0 से 139) पर ट्वीट में लिखा गया चरित्र है। यदि ट्वीट छोटा है, तो बस रिक्त होने का मूल्य दें।

फिर एक अच्छी सटीकता (अपने स्वाद के लिए व्यक्तिपरक) प्राप्त करने के लिए एक बड़ा प्रशिक्षण सेट बनाएं। प्रत्येक ट्वीट के लिए एक परिणाम मान असाइन करें, एक Apple Inc ट्वीट को 1 (सच्चा) मिलता है और एक सेब का ट्वीट (फल) 0. मिलता है। यह एक लॉजिस्टिक प्रतिगमन में पर्यवेक्षित सीखने का मामला होगा ।

यह मशीन लर्निंग है, आमतौर पर कोड करना आसान होता है और बेहतर प्रदर्शन करता है। इसे आपको दिए गए सेट से सीखना होगा, और यह हार्डकोड नहीं है।

मैं पायथन को नहीं जानता , इसलिए मैं इसके लिए कोड नहीं लिख सकता, लेकिन अगर आप मशीन लर्निंग के तर्क और सिद्धांत के लिए अधिक समय लेते हैं तो आप जिस वर्ग का अनुसरण कर रहे हैं उसे देखना चाहते हैं।

एंड्रयू एनजी द्वारा कौरसेरा कोर्स मशीन लर्निंग का प्रयास करें । आप MATLAB या ऑक्टेव पर मशीन लर्निंग सीखेंगे , लेकिन एक बार जब आप मूल बातें प्राप्त कर लेंगे तो आप किसी भी भाषा के बारे में मशीन लर्निंग लिखने में सक्षम होंगे यदि आप सरल गणित (लॉजिस्टिक रिग्रेशन में सरल) को समझते हैं।

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


धन्यवाद फ़रार। मैं इस सटीक उद्देश्य के लिए इस "हैलो वर्ल्ड" पर कुछ कोड की उम्मीद कर रहा था - यह जानने के लिए कि एमएल कैसे काम करता है। मैं कक्षा को देखूंगा। अछा लगता है।
रेयान

0

मैं इकाई मान्यता का सुझाव देने से बचने की सलाह दूंगा। क्योंकि यह कार्य एक पाठ-वर्गीकरण प्रथम और इकाई मान्यता दूसरा है (आप इसे इकाई मान्यता के बिना भी कर सकते हैं)।

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

यदि आपके पास पर्याप्त नमूने हैं, तो आपके पास 1 दिन में एक सभ्य मॉडल हो सकता है।


इसी समय, spaCyहै nerपाइपलाइन घटक, नहीं यह इस वर्गीकरण के लिए फायदेमंद हो सकता है? मुझे लगता है कि उनके मॉडल को पहचान सकते हैं Apple(क्योंकि यह दुनिया की सबसे बड़ी और सबसे अच्छी कंपनियों में से एक है) एक मॉडल से बहुत बेहतर है जिसे आप एक दिन में ले सकते हैं।
सिग्मन मस्ज़के

@ एंजाइम: एनईआर मदद कर सकता है या नहीं। जैसा कि मैं समझता हूं, आप मुख्य वर्गीकरण कार्य के लिए एक विशेषता होने के लिए नामित संस्थाओं (तथ्य यह है कि वे पाठ में मौजूद हैं) का उपयोग करना चाहते हैं। जाहिर है, एनईआर में 100% सटीकता नहीं होगी क्योंकि उच्च स्तर की अस्पष्टता है। तो मुख्य वर्गीकरण मॉडल तय करेगा कि किन परिस्थितियों में यह इस सुविधा पर भरोसा करेगा। यह हो सकता है (मुझे लगता है कि यह बहुत संभावना है) कि एक बुनियादी वर्गीकरण मॉडल एनईआर मॉडल के परिणामों को बहुत कम वजन देगा। और इसका मतलब है कि आप एनईआर पर समय बिताएंगे, जो (लगभग) उपयोग नहीं किया गया है।
डिम

मेरे कहने का मतलब नहीं। बस spacy.Docप्रत्येक पाठ से बनाएं , उनके साथ अपने NERs पर पुनरावृति doc.entsकरें और जांचें कि क्या किसी NER के पास .textविशेषता है Apple। मजेदार तथ्य, उनका पहला उदाहरण Apple से बना है।
सिग्मन मस्ज़के

और अगर कोई एक मॉडल बनाना चाहता था, तो वह शायद आरएनएन / सीएनएन और जैसे को शामिल करेगा, उन्हें तदनुसार ट्यून करेगा, वास्तुकला, सेल प्रकार आदि का पता लगाएगा, मुझे नहीं लगता कि आसान मॉडल असंतुलन और संदर्भ को अच्छी तरह से संभाल लेंगे। अपने जीवन को आसान क्यों बनाएं (जब तक आप रास्ते में कुछ सीखना नहीं चाहते हैं), अगर कोई आपके लिए पहले से ही ऐसा करता है?
सिग्मन मस्ज़के

@SzymonMaszke आपका मॉडल अधिक जटिल और प्रशिक्षित करने के लिए अधिक कठिन है। आपके मॉडल के लिए उल्लेखित उद्देश्य के लिए काम करने के लिए आपको न केवल एक एनई खोजना है, बल्कि एक सही जगह (टोकन) पर भी ढूंढना है। वर्गीकरण मॉडल के साथ जो मैं आपको सुझाव देता हूं कि आप अपने मुख्य लक्ष्य के लिए मॉडल का अनुकूलन करें - यह पहचानें कि यह Apple कंपनी या Apple फल है। यह प्रशिक्षित करना आसान है और इसलिए सबसे अधिक संभावना है कि यह अधिक सटीक होगा।
डिम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.