😦 🤚🏿 👨🏻‍🔧 जूलिया एनएलपी। हम ग्रंथों की प्रक्रिया करते हैं 🏳️ 🍈 📹

एक प्राकृतिक भाषा में ग्रंथों का विश्लेषण और प्रसंस्करण एक निरंतर सामयिक कार्य है जिसे हल किया गया है, हल किया जा रहा है और सभी उपलब्ध तरीकों से हल किया जाएगा। आज मैं जूलिया भाषा में इस समस्या को हल करने के लिए समाधान उपकरणों के बारे में बात करना चाहूंगा। बेशक, भाषा के युवाओं के कारण, इस तरह के कोई विकसित विश्लेषण उपकरण नहीं हैं, जैसे कि, उदाहरण के लिए, स्टैनफोर्ड CoreNLP, Apache OpenNLP, GATE, इत्यादि, उदाहरण के लिए, जावा भाषा के लिए। हालांकि, यहां तक कि पहले से ही विकसित किए गए पुस्तकालयों का उपयोग दोनों विशिष्ट समस्याओं को हल करने के लिए किया जा सकता है और शब्द प्रसंस्करण के क्षेत्र में रुचि रखने वाले छात्रों के लिए प्रवेश बिंदु के रूप में अनुशंसित किया जा सकता है। और जूलिया और उसके उन्नत गणितीय साधनों की वाक्यगत सादगी ग्रंथों के क्लस्टरिंग और वर्गीकरण के कार्यों में खुद को विसर्जित करना आसान बनाती है।

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

खैर, अब, पैकेज अवलोकन पर चलते हैं।

TextAnalysis.jl

TextAnalysis.jl पैकेज एक बुनियादी पुस्तकालय है जो विशिष्ट पाठ प्रसंस्करण कार्यों का एक न्यूनतम सेट लागू करता है। यह उसके साथ है जो हम शुरू करते हैं। उदाहरण आंशिक रूप से प्रलेखन से लिए गए हैं ।

दस्तावेज़

मूल इकाई एक दस्तावेज है।

निम्नलिखित प्रकार समर्थित हैं:

FileDocument - डिस्क पर एक साधारण पाठ फ़ाइल द्वारा प्रस्तुत एक दस्तावेज़

julia> pathname = "/usr/share/dict/words" "/usr/share/dict/words" julia> fd = FileDocument(pathname) A FileDocument * Language: Languages.English() * Title: /usr/share/dict/words * Author: Unknown Author * Timestamp: Unknown Time * Snippet: AA's AMD AMD's AOL AOL's Aachen Aachen's Aaliyah

StringDocument - एक दस्तावेज जो UTF-8 स्ट्रिंग द्वारा दर्शाया गया है और RAM में संग्रहीत है। StringDocument संरचना संपूर्ण रूप से पाठ को संग्रहीत करने के लिए प्रदान करता है।

 julia> str = "To be or not to be..." "To be or not to be..." julia> sd = StringDocument(str) A StringDocument{String} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: To be or not to be...

TokenDocument - एक दस्तावेज़ जो UTF-8 टोकन (हाइलाइट किए गए शब्दों) का एक क्रम है। TokenDocument संरचना टोकन का एक सेट संग्रहीत करती है, हालांकि, पूर्ण पाठ को नुकसान के बिना बहाल नहीं किया जा सकता है।

 julia> my_tokens = String["To", "be", "or", "not", "to", "be..."] 6-element Array{String,1}: "To" "be" "or" "not" "to" "be..." julia> td = TokenDocument(my_tokens) A TokenDocument{String} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: ***SAMPLE TEXT NOT AVAILABLE***

NGramDocument - UTF8 प्रतिनिधित्व में n-ग्राम के सेट के रूप में प्रस्तुत किया गया एक दस्तावेज़, अर्थात् n UTF-8 वर्णों का एक क्रम और उनकी घटना के लिए एक काउंटर। किसी दस्तावेज़ को प्रस्तुत करने का यह विकल्प विश्लेषण किए गए ग्रंथों में भाषा संरचनाओं के आकारिकी, भाषा संरचनाओं की कुछ समस्याओं से बचने के सबसे सरल तरीकों में से एक है। हालांकि, इसके लिए शुल्क उन तरीकों की तुलना में पाठ विश्लेषण की गुणवत्ता में कमी है जहां भाषा की जानकारी को ध्यान में रखा जाता है।

 julia> my_ngrams = Dict{String, Int}("To" => 1, "be" => 2, "or" => 1, "not" => 1, "to" => 1, "be..." => 1) Dict{String,Int64} with 6 entries: "or" => 1 "be..." => 1 "not" => 1 "to" => 1 "To" => 1 "be" => 2 julia> ngd = NGramDocument(my_ngrams) A NGramDocument{AbstractString} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: ***SAMPLE TEXT NOT AVAILABLE***

या एक छोटा विकल्प:

 julia> str = "To be or not to be..." "To be or not to be..." julia> ngd = NGramDocument(str, 2) NGramDocument{AbstractString}(Dict{AbstractString,Int64}("To be" => 1,"or not" => 1,"be or" => 1,"or" => 1,"not to" => 1,"not" => 1,"to be" => 1,"to" => 1,"To" => 1,"be" => 2…), 2, TextAnalysis.DocumentMetadata( Languages.English(), "Untitled Document", "Unknown Author", "Unknown Time"))

एक दस्तावेज़ भी केवल सामान्य दस्तावेज़ निर्माता का उपयोग करके बनाया जा सकता है, और पुस्तकालय दस्तावेज़ के उचित कार्यान्वयन को ढूंढेगा।

 julia> Document("To be or not to be...") A StringDocument{String} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: To be or not to be... julia> Document("/usr/share/dict/words") A FileDocument * Language: Languages.English() * Title: /usr/share/dict/words * Author: Unknown Author * Timestamp: Unknown Time * Snippet: AA's AMD AMD's AOL AOL's Aachen Aachen's Aaliyah julia> Document(String["To", "be", "or", "not", "to", "be..."]) A TokenDocument{String} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: ***SAMPLE TEXT NOT AVAILABLE*** julia> Document(Dict{String, Int}("a" => 1, "b" => 3)) A NGramDocument{AbstractString} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: ***SAMPLE TEXT NOT AVAILABLE***

जैसा कि आप देख सकते हैं, दस्तावेज़ के शरीर में पाठ / टोकन और मेटाडेटा शामिल हैं। दस्तावेज़ का text(...) विधि का उपयोग करके प्राप्त किया जा सकता है:

 julia> td = TokenDocument("To be or not to be...") TokenDocument{String}(["To", "be", "or", "not", "to", "be"], TextAnalysis.DocumentMetadata( Languages.English(), "Untitled Document", "Unknown Author", "Unknown Time")) julia> text(td) ┌ Warning: TokenDocument's can only approximate the original text └ @ TextAnalysis ~/.julia/packages/TextAnalysis/pcFQf/src/document.jl:111 "To be or not to be" julia> tokens(td) 6-element Array{String,1}: "To" "be" "or" "not" "to" "be"

उदाहरण स्वचालित रूप से पार्स टोकन के साथ एक दस्तावेज़ प्रदर्शित करता है। हम देखते हैं कि कॉल टू text(td) ने एक चेतावनी जारी की थी कि टेक्स्ट केवल लगभग बहाल हो गया था, क्योंकि TokenDocument शब्द सीमांकक को संग्रहीत नहीं करता है। tokens(td) की कॉल ने वास्तव में हाइलाइट किए गए शब्दों को प्राप्त करना संभव बना दिया।

आप दस्तावेज़ से मेटाडेटा का अनुरोध कर सकते हैं:

 julia> StringDocument("This document has too foo words") A StringDocument{String} * Language: Languages.English() * Title: Untitled Document * Author: Unknown Author * Timestamp: Unknown Time * Snippet: This document has too foo words julia> language(sd) Languages.English() julia> title(sd) "Untitled Document" julia> author(sd) "Unknown Author" julia> timestamp(sd) "Unknown Time"

और उन सभी को संबंधित कार्यों द्वारा बदला जा सकता है। जूलिया में संशोधन कार्यों की सूचना रूबी भाषा में ही है। एक फ़ंक्शन जो किसी वस्तु को संशोधित करता है एक प्रत्यय है ! :

 julia> using TextAnalysis.Languages julia> language!(sd, Languages.Russian()) Languages.Russian () julia> title!(sd, "") "" julia> author!(sd, " ..") " .." julia> import Dates:now julia> timestamp!(sd, string(now())) "2019-11-09T22:53:38.383"

UTF-8 के साथ तार की विशेषताएं

जूलिया स्ट्रिंग्स को संसाधित करते समय UTF-8 एन्कोडिंग का समर्थन करता है, इसलिए इसमें गैर-लैटिन अक्षर का उपयोग करने में कोई समस्या नहीं है। किसी भी चरित्र प्रसंस्करण विकल्प स्वाभाविक रूप से उपलब्ध हैं। हालांकि, यह ध्यान रखें कि जूलिया के लिए पंक्ति अनुक्रम बाइट्स हैं, वर्ण नहीं। और प्रत्येक चरित्र को बाइट्स की एक अलग संख्या द्वारा दर्शाया जा सकता है। और UNICODE पात्रों के साथ काम करने के लिए अलग-अलग तरीके हैं। विवरण के लिए यूनिकोड-एंड-यूटीएफ -8 देखें। लेकिन यहाँ एक सरल उदाहरण है। चलो गणितीय UNICODE वर्णों के साथ एक रेखा सेट करें जिसे x और y से रिक्त स्थान द्वारा अलग किया गया है:

 julia> s = "\u2200 x \u2203 y" "∀ x ∃ y" julia> length(s) # ! 7 julia> ncodeunits(s) # ! 11

अब देखते हैं सूचकांकों पर:

 julia> s[1] '∀': Unicode U+2200 (category Sm: Symbol, math) julia> s[2] ERROR: StringIndexError("∀ x ∃ y", 2) [...] julia> s[3] ERROR: StringIndexError("∀ x ∃ y", 3) Stacktrace: [...] julia> s[4] ' ': ASCII/Unicode U+0020 (category Zs: Separator, space)

उदाहरण स्पष्ट रूप से दिखाता है कि सूचकांक 1 ने हमें प्रतीक index प्राप्त करने की अनुमति दी है। लेकिन बाद के सभी अनुक्रमणिका में 3 समावेशी, एक त्रुटि का कारण बने। और केवल 4 वें सूचकांक ने एक स्थान का उत्पादन किया, स्ट्रिंग में अगले चरित्र के रूप में। हालांकि, एक स्ट्रिंग में अनुक्रमित द्वारा वर्णों की सीमाओं को निर्धारित करने के लिए, उपयोगी कार्य हैं (पिछले सूचकांक), nextind (अगला सूचकांक) और thisind (यह सूचकांक)। उदाहरण के लिए, ऊपर पाए गए अंतर के लिए, हम पूछते हैं कि पिछले एक की सीमा कहां है:

 julia> prevind(s, 4) 1

हमें प्रतीक 1 की शुरुआत के रूप में सूचकांक 1 मिला।

 julia> thisind(s, 3) 1

इंडेक्स 3 की जाँच की और वही मान्य 1 प्राप्त किया।

यदि हमें सभी पात्रों को "खत्म" करने की आवश्यकता है, तो इसे कम से कम दो सरल तरीकों से किया जा सकता है:
1) डिजाइन का उपयोग कर:

 julia> for c in s print(c) end ∀ x ∃ y

2) eachindex enumerator का उपयोग eachindex :

 julia> collect(eachindex(s)) 7-element Array{Int64,1}: 1 4 5 6 7 10 11 julia> for i in eachindex(s) print(s[i]) end ∀ x ∃ y

दस्तावेज़ प्रीप्रोसेसिंग

यदि दस्तावेज़ का पाठ कुछ बाहरी प्रतिनिधित्व से प्राप्त किया गया था, तो यह काफी संभव है कि बाइट स्ट्रीम में एन्कोडिंग त्रुटियां हो सकती हैं। उन्हें समाप्त करने के लिए, remove_corrupt_utf8!(sd) फ़ंक्शन का उपयोग करें। तर्क ऊपर चर्चा किए गए दस्तावेज़ हैं।

TextAnalysis पैकेज में दस्तावेजों के प्रसंस्करण के लिए मुख्य कार्य prepare!(...) । उदाहरण के लिए, पाठ से विराम चिह्न हटा दें:

 julia> str = StringDocument("here are some punctuations !!!...") julia> prepare!(str, strip_punctuation) julia> text(str) "here are some punctuations "

इसके अलावा, वर्ड प्रोसेसिंग में एक उपयोगी कदम लोअर केस में सभी अक्षरों का रूपांतरण है, क्योंकि यह एक दूसरे के साथ शब्दों की तुलना को सरल बनाता है। इस मामले में, सामान्य मामले में, हमें यह समझना चाहिए कि हम पाठ के बारे में महत्वपूर्ण जानकारी खो सकते हैं, उदाहरण के लिए, यह तथ्य कि शब्द एक उचित नाम है या शब्द एक वाक्य की सीमा है। लेकिन यह सब आगे की प्रक्रिया के मॉडल पर निर्भर करता है। लोअरकेस को remove_case!() द्वारा किया जाता है remove_case!() फ़ंक्शन।

 julia> sd = StringDocument("Lear is mad") A StringDocument{String} julia> remove_case!(sd) julia> text(sd) "lear is mad"

रास्ते के साथ, हम कचरा शब्दों को हटा सकते हैं, अर्थात्, जो मैचों के लिए सूचना पुनर्प्राप्ति और विश्लेषण में कोई फायदा नहीं है। यह स्पष्ट रूप से remove_words!(…) फ़ंक्शन और इन स्टॉप शब्दों की एक सरणी का उपयोग करके किया जा सकता है।

 julia> remove_words!(sd, ["lear"]) julia> text(sd) " is mad"

हटाए जाने वाले शब्दों में, लेख, प्रस्ताव, सर्वनाम, संख्याएं भी हैं और केवल शब्दों को रोकना है, जो घटना की आवृत्ति में परजीवी हैं। प्रत्येक विशिष्ट भाषा के लिए, ये शब्दकोश व्यक्तिगत हैं। और वे Language.jl पैकेज में सेट किए गए हैं। संख्याएं हमें परेशान करती हैं क्योंकि भविष्य के मॉडल में एक थर्मल दस्तावेज़, वे मैट्रिक्स के आयाम में सुधार के बिना बहुत बढ़ा सकते हैं, उदाहरण के लिए, ग्रंथों की क्लस्टरिंग। हालांकि, खोज समस्याओं में, उदाहरण के लिए, संख्याओं को छोड़ना हमेशा संभव नहीं होता है।

उपलब्ध सफाई विधियों में से निम्नलिखित विकल्प हैं:

prepare!(sd, strip_articles)
prepare!(sd, strip_indefinite_articles)
prepare!(sd, strip_definite_articles)
prepare!(sd, strip_preposition)
prepare!(sd, strip_pronouns)
prepare!(sd, strip_stopwords)
prepare!(sd, strip_numbers)
prepare!(sd, strip_non_letters)
prepare!(sd, strip_spares_terms)
prepare!(sd, strip_frequent_terms)
prepare!(sd, strip_html_tags)

विकल्प संयुक्त हो सकते हैं। उदाहरण के लिए, prepare! करने के prepare! एक कॉल में prepare! एक साथ लेख, संख्या और html टैग हटाएं - prepare!(sd, strip_articles| strip_numbers| strip_html_tags)

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

 julia> sd = StringDocument("   ") StringDocument{String}("   ", TextAnalysis.DocumentMetadata(Languages.English(), "Untitled Document", "Unknown Author", "Unknown Time")) julia> language!(sd, Languages.Russian()) Languages.Russian() julia> stem!(sd) julia> text(sd) "   "

दस्तावेज़ निकाय

कॉर्पस को दस्तावेजों के एक सेट के रूप में समझा जाता है जिसे उसी नियमों के अनुसार संसाधित किया जाएगा। TextAnalysis पैकेज एक शब्द दस्तावेज़ मैट्रिक्स के गठन को लागू करता है। और इसके निर्माण के लिए, हमें तुरंत दस्तावेजों का एक पूरा सेट चाहिए। दस्तावेजों के लिए एक सरल उदाहरण में:
D1 = "I like databases"
D2 = "I hate databases"

यह मैट्रिक्स जैसा दिखता है:

	मैं	जैसा	नफरत	डेटाबेस
डी 1	1	1	0	1
डी 2	1	0	1	1

स्तंभों को दस्तावेजों के शब्दों द्वारा दर्शाया जाता है, और पंक्तियों को दस्तावेजों के पहचानकर्ता (या अनुक्रमित) होते हैं। तदनुसार, यदि दस्तावेज़ में शब्द (शब्द) दिखाई नहीं देता है, तो सेल 0 होगा। और 1 अगर यह किसी भी समय होता है। अधिक जटिल मॉडल घटना की आवृत्ति (टीएफ मॉडल) और पूरे शरीर (टीएफ-आईडीएफ) के संबंध में महत्व दोनों को ध्यान में रखते हैं।

हम Corpus() कंस्ट्रक्टर का उपयोग करके शरीर का निर्माण कर सकते हैं:

 crps = Corpus([StringDocument("Document 1"), StringDocument("Document 2")])

यदि हम तुरंत शर्तों की सूची का अनुरोध करते हैं, तो हमें यह मिलता है:

 julia> lexicon(crps) Dict{String,Int64} with 0 entries

और, यहाँ, लाइब्रेरी को update_lexicon!(crps) करने के लिए मजबूर करने वाले सभी शब्दों को update_lexicon!(crps) करने के लिए मजबूर किया गया है, जो update_lexicon!(crps) का उपयोग कर update_lexicon!(crps) , हमें एक अलग परिणाम मिलता है:

 julia> update_lexicon!(crps) julia> lexicon(crps) Dict{String,Int64} with 3 entries: "1" => 1 "2" => 1 "Document" => 2

अर्थात्, हम चयनित निकाय (शब्द और संख्या) और दस्तावेज़ निकाय में उनकी प्रविष्टियों की संख्या देख सकते हैं।

उसी समय, हम शब्द की आवृत्ति को स्पष्ट कर सकते हैं, उदाहरण के लिए, "दस्तावेज़":

 julia> lexical_frequency(crps, "Document") 0.5

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

 julia> update_inverse_index!(crps) julia> inverse_index(crps) Dict{String,Array{Int64,1}} with 3 entries: "1" => [1] "2" => [2] "Document" => [1, 2]

एक पूरे के रूप में मामले के लिए, आप प्रीप्रोसेसिंग कार्यों को लागू कर सकते हैं, प्रत्येक व्यक्तिगत दस्तावेज़ के लिए। prepare! फ़ंक्शन का एक और तरीका उपयोग किया जाता है prepare! पहले माना जाता है। यहाँ, पहला तर्क मामला है।

 julia> crps = Corpus([StringDocument("Document ..!!"), StringDocument("Document ..!!")]) julia> prepare!(crps, strip_punctuation) julia> text(crps[1]) "Document " julia> text(crps[2]) "Document "

व्यक्तिगत दस्तावेजों के लिए, आप पूरे शरीर के लिए मेटाडेटा का अनुरोध कर सकते हैं।

 julia> crps = Corpus([StringDocument("Name Foo"), StringDocument("Name Bar")]) julia> languages(crps) 2-element Array{Languages.English,1}: Languages.English() Languages.English() julia> titles(crps) 2-element Array{String,1}: "Untitled Document" "Untitled Document" julia> authors(crps) 2-element Array{String,1}: "Unknown Author" "Unknown Author" julia> timestamps(crps) 2-element Array{String,1}: "Unknown Time" "Unknown Time"

आप एक बार में पूरे शरीर के लिए समान मान सेट कर सकते हैं या विशिष्ट दस्तावेज़ों के लिए उनके लिए तत्व-दर-तत्व मानों के साथ एक सरणी पास करके।

 julia> languages!(crps, Languages.German()) julia> titles!(crps, "") julia> authors!(crps, "Me") julia> timestamps!(crps, "Now") julia> languages!(crps, [Languages.German(), Languages.English julia> titles!(crps, ["", "Untitled"]) julia> authors!(crps, ["Ich", "You"]) julia> timestamps!(crps, ["Unbekannt", "2018"])

हाइलाइटिंग सुविधा

फ़ीचर निष्कर्षण मशीन सीखने के बुनियादी चरणों में से एक है। यह सीधे इस लेख के विषय से संबंधित नहीं है, लेकिन TextAnalysis पैकेज के लिए प्रलेखन में एक बहुत बड़ा खंड इस बहुत ही सूत्रीकरण में सुविधाओं की पहचान के लिए समर्पित है। इस खंड में दोनों शामिल हैं, वास्तव में, एक शब्द-दस्तावेज़ मैट्रिक्स का निर्माण, और कई अन्य तरीके। https://juliatext.imtqy.com/TextAnalysis.jl/dev/features/

हम प्रस्तावित विकल्पों पर संक्षेप में विचार करते हैं।

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

तीन दस्तावेज़ों के साथ सबसे सरल उदाहरण लें, जिनमें Document , 1 , 2 , 3 ।

 julia> using TextAnalysis julia> crps = Corpus([StringDocument("Document 1"), StringDocument("Document 2"), StringDocument("Document 1 3")])

हम प्रीप्रोसेसिंग का उपयोग नहीं करेंगे। लेकिन हम पूर्ण लक्सिकॉन और टर्म दस्तावेज़ के मैट्रिक्स का निर्माण करेंगे:

 julia> update_lexicon!(crps) julia> m = DocumentTermMatrix(crps) DocumentTermMatrix( [1, 1] = 1 [3, 1] = 1 [2, 2] = 1 [3, 3] = 1 [1, 4] = 1 [2, 4] = 1 [3, 4] = 1, ["1", "2", "3", "Document"], Dict("1" => 1,"2" => 2,"Document" => 4,"3" => 3))

वेरिएबल m में टाइप DocumentTermMatrix का मान है। मुद्रित परिणाम में, हम देखते हैं कि आयाम 4 शर्तों में 3 दस्तावेज़ हैं, जिसमें Document और नंबर 1 , 2 , 3 शब्द शामिल हैं। मॉडल के आगे उपयोग के लिए, हमें पारंपरिक प्रतिनिधित्व में एक मैट्रिक्स की आवश्यकता है। हम इसे dtm() विधि का उपयोग करके प्राप्त कर सकते हैं:

 julia> dtm(m) 3×4 SparseArrays.SparseMatrixCSC{Int64,Int64} with 7 stored entries: [1, 1] = 1 [3, 1] = 1 [2, 2] = 1 [3, 3] = 1 [1, 4] = 1 [2, 4] = 1 [3, 4] = 1

यह विकल्प SparseMatrixCSC प्रकार द्वारा प्रस्तुत किया गया है, जो कि बहुत ही विरल मैट्रिक्स का प्रतिनिधित्व करने में किफायती है, लेकिन इसमें सीमित संख्या में पुस्तकालय ही हैं जो इसका समर्थन करते हैं। शब्द दस्तावेज़ मैट्रिक्स के आकार की समस्या इस तथ्य के कारण है कि संसाधित दस्तावेजों की संख्या के साथ शब्दों की संख्या बहुत जल्दी बढ़ती है। यदि आप दस्तावेजों को पूर्व-प्रक्रिया नहीं करते हैं, तो उनके सभी शब्द रूपों, संख्याओं, तिथियों के साथ बिल्कुल सभी शब्द इस मैट्रिक्स में आ जाएंगे। भले ही मुख्य रूप में कमी के कारण शब्द रूपों की संख्या कम हो, शेष तनों की संख्या हजारों - दसियों हजारों के क्रम की होगी। अर्थात्, दस्तावेज़ दस्तावेज़ मैट्रिक्स का पूर्ण आयाम इस मात्रा के कुल उत्पाद द्वारा संसाधित दस्तावेजों की संख्या से निर्धारित होता है। एक पूर्ण मैट्रिक्स के लिए न केवल इकाइयों बल्कि जीरो को स्टोर करने की आवश्यकता होती है, हालांकि SparseMatrixCSC तुलना में SparseMatrixCSC उपयोग करना आसान है। आप इसे एक अन्य विधि dtm(..., :dense) द्वारा प्राप्त कर सकते हैं या collect() विधि का उपयोग करके विरल मैट्रिक्स को पूर्ण रूप में परिवर्तित कर सकते हैं:

 julia> dtm(m, :dense) 3×4 Array{Int64,2}: 1 0 0 1 0 1 0 1 1 0 1 1

यदि आप शब्दों की एक सरणी प्रिंट करते हैं, तो प्रत्येक पंक्ति में दस्तावेजों की मूल संरचना (शब्दों के मूल क्रम को ध्यान में नहीं रखा जाता है) को देखना आसान है।

 julia> m.terms 4-element Array{String,1}: "1" "2" "3" "Document"

आवृत्ति मॉडल के लिए दस्तावेज़ दस्तावेज़ मैट्रिक्स को tf() और tf_idf() विधियों का उपयोग करके प्राप्त किया जा सकता है:

 julia> tf(m) |> collect 3×4 Array{Float64,2}: 0.5 0.0 0.0 0.5 0.0 0.5 0.0 0.5 0.333333 0.0 0.333333 0.333333

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

और TF-IDF और tf_idf() विधि के लिए:

 julia> tdm = tf_idf(m) |> collect 3×4 Array{Float64,2}: 0.202733 0.0 0.0 0.0 0.0 0.549306 0.0 0.0 0.135155 0.0 0.366204 0.0

और इस मॉडल में यह देखना आसान है कि शब्द Document , जो सभी दस्तावेजों में पाया जाता है, का मूल्य 0. है। तीसरे दस्तावेज़ में शब्द 3 में एक ही दस्तावेज़ में 1 से अधिक वजन प्राप्त हुआ है, क्योंकि 1 भी पहले दस्तावेज़ में पाया गया है। ।

परिणामी मेट्रिक्स का उपयोग करना बहुत आसान है, उदाहरण के लिए, क्लस्टरिंग दस्तावेजों की समस्या को हल करने के लिए। ऐसा करने के लिए, आपको क्लस्टरिंग पैकेज की आवश्यकता होगी। हम सरलतम k- साधन क्लस्टरिंग एल्गोरिथ्म का उपयोग करते हैं, जिसे वांछित समूहों की संख्या निर्दिष्ट करने की आवश्यकता होती है। हम अपने तीन दस्तावेजों को दो समूहों में विभाजित करते हैं। kmeans लिए इनपुट मैट्रिक्स एक फीचर मैट्रिक्स है, जहां पंक्तियाँ सुविधाओं का प्रतिनिधित्व करती हैं और कॉलम पैटर्न का प्रतिनिधित्व करते हैं। इसलिए, ऊपर प्राप्त मेट्रोपिस को स्थानांतरित करना होगा।

 julia> using Clustering julia> R = kmeans(tdm', 2; maxiter=200, display=:iter) Iters objv objv-change | affected ------------------------------------------------------------- 0 1.386722e-01 1 6.933608e-02 -6.933608e-02 | 0 2 6.933608e-02 0.000000e+00 | 0 K-means converged with 2 iterations (objv = 0.06933608051588186) KmeansResult{Array{Float64,2},Float64,Int64}( [0.0 0.16894379504506848; 0.5493061443340549 0.0; 0.0 0.1831020481113516; 0.0 0.0], [2, 1, 2], [0.03466804025794093, 0.0, 0.03466804025794093], [1, 2], [1, 2], 0.06933608051588186, 2, true) julia> c = counts(R) #    2-element Array{Int64,1}: 1 2 julia> a = assignments(R) #     3-element Array{Int64,1}: 2 1 2 julia> M = R.centers #     4×2 Array{Float64,2}: 0.0 0.168944 0.549306 0.0 0.0 0.183102 0.0 0.0

नतीजतन, हम देखते हैं कि पहले क्लस्टर में एक दस्तावेज़ होता है, क्लस्टर नंबर 2 में दो दस्तावेज़ होते हैं। इसके अलावा, R.centers समूहों के केंद्र वाले मैट्रिक्स स्पष्ट रूप से दिखाते हैं कि पहला कॉलम शब्द 2 से "आकर्षित" है। दूसरा कॉलम 1 और 3 की उपस्थिति से निर्धारित होता है।

Clustering.jl पैकेज में क्लस्टरिंग एल्गोरिदम का एक विशिष्ट सेट शामिल है, उनमें से: K- साधन, K-medoids, Affinity Propagation, घनत्व-आधारित स्थानिक क्लस्टरिंग ऑफ़ शोर (DBSCAN), मार्कोव क्लस्टरिंग एल्गोरिथम (MCL), फ़ज़ी सी-मीन्स क्लस्टरिंग,। पदानुक्रमित क्लस्टरिंग (एकल, औसत, पूर्ण, वार्ड का संबंध)। लेकिन उनकी प्रयोज्यता का विश्लेषण इस लेख के दायरे से परे है।

TextAnalysis.jl पैकेज वर्तमान में सक्रिय विकास के तहत है, इसलिए कुछ कार्य केवल गिट रिपॉजिटरी से सीधे पैकेज को स्थापित करते समय उपलब्ध होंगे। यह करना मुश्किल नहीं है, लेकिन यह केवल उन लोगों को सलाह दी जा सकती है जो निकट भविष्य में समाधान के संचालन की योजना नहीं बनाते हैं:

 julia> ] (v1.2) pkg> add https://github.com/JuliaText/TextAnalysis.jl

हालाँकि, आपको समीक्षा में इन कार्यों को अनदेखा नहीं करना चाहिए। इसलिए, हम उन पर भी विचार करते हैं।

सुधारों में से एक Okapi BM25 रैंकिंग फ़ंक्शन का उपयोग है। पिछले tf मॉडल के समान। tf_idf , हम bm_25(m) विधि का उपयोग करते हैं। परिणामी मैट्रिक्स का उपयोग पिछले मामलों के समान है।

तरीकों का उपयोग करके ग्रंथों की टॉन्सिलिटी का विश्लेषण किया जा सकता है:

 model = SentimentAnalyzer(doc) model = SentimentAnalyzer(doc, handle_unknown)

इसके अलावा, doc उपरोक्त दस्तावेज़ प्रकारों में से एक है। handle_unknown - अज्ञात शब्दों को संसाधित करने के लिए फ़ंक्शन। TonDB विश्लेषण IMDB पैकेज के आधार पर Flux.jl पैकेज का उपयोग करके कार्यान्वित किया जाता है। रिटर्न वैल्यू 0 से 1 के रेंज में है।

दस्तावेज़ सामान्यीकरण को summarize(d, ns) विधि का उपयोग करके लागू किया जा सकता है। पहला तर्क दस्तावेज़ है। दूसरा है ns= अंत में वाक्यों ns= संख्या।

 julia> s = StringDocument("Assume this Short Document as an example. Assume this as an example summarizer. This has too foo sentences.") julia> summarize(s, ns=2) 2-element Array{SubString{String},1}: "Assume this Short Document as an example." "This has too foo sentences."

किसी भी पाठ विश्लेषण पुस्तकालय का एक बहुत महत्वपूर्ण घटक सिंटैक्टिक पार्सर है जो वर्तमान में विकास के अधीन है, जो भाषण के कुछ हिस्सों को अलग करता है - पीओएस (भाषण का हिस्सा)। इसका उपयोग करने के लिए कई विकल्प हैं। विवरण के लिए, भाषण टैगिंग के भाग देखें ।
। Tagging को कहा जाता है क्योंकि स्रोत पाठ में प्रत्येक शब्द के लिए, एक टैग बनाया जाता है जिसका अर्थ है भाषण का हिस्सा।

कार्यान्वयन के दो विकल्प विकास के अधीन हैं। पहला है एवरेज परसेप्ट्रोन एल्गोरिथम। दूसरा तंत्रिका नेटवर्क आर्किटेक्चर LSTM, CNN और CRF पद्धति के उपयोग पर आधारित है। यहाँ एक सरल वाक्य मार्कअप का उदाहरण दिया गया है।

 julia> pos = PoSTagger() julia> sentence = "This package is maintained by John Doe." "This package is maintained by John Doe." julia> tags = pos(sentence) 8-element Array{String,1}: "DT" "NN" "VBZ" "VBN" "IN" "NNP" "NNP" "."

भाषण के संक्षिप्त अर्थ के भाग की सूची पेन ट्रीबैंक से ली गई है। विशेष रूप से, DT - निर्धारक, NN - संज्ञा, एकवचन या द्रव्यमान, VBZ - Verb, तीसरा व्यक्ति एकवचन वर्तमान, Verb, भूतकालिक कृदंत, IN - पूर्वसर्ग या अधीनता संयुग्मन, NNP - व्यक्तिवाचक संज्ञा, एकवचन।

इस मार्कअप के परिणामों को दस्तावेजों के वर्गीकरण के लिए अतिरिक्त सुविधाओं के रूप में भी इस्तेमाल किया जा सकता है।

आयाम घटाने के तरीके

टेक्स्टअनलिसिस आश्रित शर्तों को परिभाषित करके आयामीता को कम करने के लिए दो विकल्प प्रदान करता है। यह अव्यक्त अर्थ विश्लेषण - एलएसए और अव्यक्त डिरिचलेट प्लेसमेंट - एलडीए।

एलएसए का मुख्य कार्य टर्म-डॉक्यूमेंट मैट्रिक्स (TF-IDF का उपयोग करके) को 3 मेट्रिसेस में अपघटन प्राप्त करना है, जिसका उत्पाद लगभग मूल से मेल खाता है।

 julia> crps = Corpus([StringDocument("this is a string document"), TokenDocument("this is a token document")]) julia> update_lexicon!(crps) julia> m = DocumentTermMatrix(crps) julia> tf_idf(m) |> collect 2×6 Array{Float64,2}: 0.0 0.0 0.0 0.138629 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.138629 julia> F2 = lsa(m) SVD{Float64,Float64,Array{Float64,2}}([1.0 0.0; 0.0 1.0], [0.138629, 0.138629], [0.0 0.0 … 0.0 0.0; 0.0 0.0 … 0.0 1.0])

, -, TF-IDF . SVD, , .

LDA . एक उदाहरण:

 julia> crps = Corpus([StringDocument("This is the Foo Bar Document"), StringDocument("This document has too Foo words")]) julia> update_lexicon!(crps) julia> m = DocumentTermMatrix(crps) julia> k = 2 # number of topics julia> iterations = 1000 # number of gibbs sampling iterations julia> α = 0.1 # hyper parameter julia> β = 0.1 # hyper parameter julia> ϕ, θ = lda(m, k, iterations, α, β) ( [2 , 1] = 0.333333 [2 , 2] = 0.333333 [1 , 3] = 0.222222 [1 , 4] = 0.222222 [1 , 5] = 0.111111 [1 , 6] = 0.111111 [1 , 7] = 0.111111 [2 , 8] = 0.333333 [1 , 9] = 0.111111 [1 , 10] = 0.111111, [0.5 1.0; 0.5 0.0])

k lda , . ϕ θ , ntopics × nwords , — ntopics × ndocs .

— . . , . NaiveBayesClassifier() . — fit!() :

 using TextAnalysis: NaiveBayesClassifier, fit!, predict m = NaiveBayesClassifier([:legal, :financial]) fit!(m, "this is financial doc", :financial) fit!(m, "this is legal doc", :legal)

predict :

 julia> predict(m, "this should be predicted as a legal document") Dict{Symbol,Float64} with 2 entries: :legal => 0.666667 :financial => 0.333333

, , :legal .

TextAnalysis.jl . , . MLJ.jl . AdaBoostClassifier, BaggingClassifier, BernoulliNBClassifier, ComplementNBClassifier, ConstantClassifier, XGBoostClassifier, DecisionTreeClassifier. - LSA, . .

TextAnalysis.jl CRF — Conditional Random Fields , Flux.jl, . .

TextAnalysis.jl — NER . NERTagger() :

PER:
LOC:
ORG:
MISC:
O:

 julia> sentence = "This package is maintained by John Doe." "This package is maintained by John Doe." julia> tags = ner(sentence) 8-element Array{String,1}: "O" "O" "O" "O" "O" "PER" "PER" "O"

NERTagger TextAnalysis. .

StringDistances.jl

. , , . . , StringDistances.jl . :

 using StringDistances compare("martha", "martha", Hamming()) #> 1.0 compare("martha", "marhta", Jaro()) #> 0.9444444444444445 compare("martha", "marhta", Winkler(Jaro())) #> 0.9611111111111111 compare("william", "williams", QGram(2)) #> 0.9230769230769231 compare("william", "williams", Winkler(QGram(2))) #> 0.9538461538461539

compare — . , 1 — . 0 — .

, Jaro-Winkler. , . RatcliffObershelp, , . , . .

  compare("mariners vs angels", "angels vs mariners", RatcliffObershelp()) #> 0.44444 compare("mariners vs angels", "angels vs mariners", TokenSort(RatcliffObershelp()) #> 1.0 compare("mariners vs angels", "los angeles angels at seattle mariners", Jaro()) #> 0.559904 compare("mariners vs angels", "los angeles angels at seattle mariners", TokenSet(Jaro())) #> 0.944444 compare("mariners vs angels", "los angeles angels at seattle mariners", TokenMax(RatcliffObershelp())) #> 0.855

, , . , TokenSort , . Julia — Julia, .

WordTokenizers.jl

WordTokenizers.jl . , , TextAnalysis.jl.

— . , tokenize(text) .

 julia> using WordTokenizers julia> text = "I cannot stand when they say \"Enough is enough.\""; julia> tokenize(text) |> print # Default tokenizer SubString{String}["I", "can", "not", "stand", "when", "they", "say", "``", "Enough", "is", "enough", ".", "''"]

WordTokenizers .

 julia> text = "The leatherback sea turtle is the largest, measuring six or seven feet (2 m) in length at maturity, and three to five feet (1 to 1.5 m) in width, weighing up to 2000 pounds (about 900 kg). Most other species are smaller, being two to four feet in length (0.5 to 1 m) and proportionally less wide. The Flatback turtle is found solely on the northerncoast of Australia."; julia> split_sentences(text) 3-element Array{SubString{String},1}: "The leatherback sea turtle is the largest, measuring six or seven feet (2 m) in length at maturity, and three to five feet (1 to 1.5 m) in width, weighing up to 2000 pounds (about900 kg). " "Most other species are smaller, being two to four feet in length (0.5 to 1 m) and proportionally less wide. " "The Flatback turtle is found solely on the northern coast of Australia." julia> tokenize.(split_sentences(text)) 3-element Array{Array{SubString{String},1},1}: SubString{String}["The", "leatherback", "sea", "turtle", "is", "the", "largest", ",", "measuring", "six" … "up", "to", "2000", "pounds", "(", "about", "900", "kg", ")", "."] SubString{String}["Most", "other", "species", "are", "smaller", ",", "being", "two", "to", "four" … "0.5", "to", "1", "m", ")", "and", "proportionally", "less", "wide", "."] SubString{String}["The", "Flatback", "turtle", "is", "found", "solely", "on", "the", "northern", "coast", "of", "Australia", "."]

Poorman's tokenizer — . , split .
Punctuation space tokenize — . , .
Penn Tokenizer — , Penn Treebank.
Improved Penn Tokenizer — , NLTK.
NLTK Word tokenizer — , NLTK, , UNICODE- .
Reversible Tokenizer — , .
TokTok Tokenizer — , .
Tweet Tokenizer — , , , HTML- .

set_tokenizer(nltk_word_tokenize)

Embeddings.jl

Embeddings.jl . , , , , , , . Word2Vec. , : king - man + woman = queen . , , . , , , Wikipedia, . , . «semantic space», , «semantic distance». , , , «» «» . , , , .

, «embedding» , , , . , , , , , , . , -, . , . , . .

Embeddings.jl : Word2Vec, GloVe (English only), FastText. . , , . — , . , , word2vec, 8-16 . , .

, , DataDeps.jl . , (" "). , Embedding.jl , , . , .

 ENV["DATADEPS_ALWAYS_ACCEPT"] = true

— . ~/.julia/datadeps .

. — :

 using Embeddings const embtable = load_embeddings(Word2Vec) # or load_embeddings(FastText_Text) or ... const get_word_index = Dict(word=>ii for (ii,word) in enumerate(embtable.vocab)) function get_embedding(word) ind = get_word_index[word] emb = embtable.embeddings[:,ind] return emb end

— :

 julia> get_embedding("blue") 300-element Array{Float32,1}: 0.01540828 0.03409082 0.0882124 0.04680265 -0.03409082 ...

WordTokenizers TextAnalysis, . , Julia:

 julia> a = rand(5) 5-element Array{Float64,1}: 0.012300397820243392 0.13543646950484067 0.9780602985106086 0.24647179461578816 0.18672770774122105 julia> b = ones(5) 5-element Array{Float64,1}: 1.0 1.0 1.0 1.0 1.0 julia> a+b 5-element Array{Float64,1}: 1.0123003978202434 1.1354364695048407 1.9780602985106086 1.2464717946157882 1.186727707741221

Clustering.jl. , — . MLJ.jl. , https://github.com/JuliaStats/Distances.jl , :

Euclidean distance
Squared Euclidean distance
Periodic Euclidean distance
Cityblock distance
Total variation distance
Jaccard distance
Rogers-Tanimoto distance
Chebyshev distance
Minkowski distance
Hamming distance
Cosine distance
Correlation distance
Chi-square distance
Kullback-Leibler divergence
Generalized Kullback-Leibler divergence
Rényi divergence
Jensen-Shannon divergence
Mahalanobis distance
Squared Mahalanobis distance
Bhattacharyya distance
Hellinger distance
Haversine distance
Mean absolute deviation
Mean squared deviation
Root mean squared deviation
Normalized root mean squared deviation
Bray-Curtis dissimilarity
Bregman divergence

Transformers.jl

Transformers.jl — Julia «Transformers», BERT Google. , NER — , .

Transformers.jl Flux.jl , , , Julia- , . Flux.jl CPU GPU, , , , .

BERT , . :

 using Transformers using Transformers.Basic using Transformers.Pretrain using Transformers.Datasets using Transformers.BidirectionalEncoder using Flux using Flux: onehotbatch, gradient import Flux.Optimise: update! using WordTokenizers ENV["DATADEPS_ALWAYS_ACCEPT"] = true const FromScratch = false #use wordpiece and tokenizer from pretrain const wordpiece = pretrain"bert-uncased_L-12_H-768_A-12:wordpiece" const tokenizer = pretrain"bert-uncased_L-12_H-768_A-12:tokenizer" const vocab = Vocabulary(wordpiece) const bert_model = gpu( FromScratch ? create_bert() : pretrain"bert-uncased_L-12_H-768_A-12:bert_model" ) Flux.testmode!(bert_model) function vectorize(str::String) tokens = str |> tokenizer |> wordpiece text = ["[CLS]"; tokens; "[SEP]"] token_indices = vocab(text) segment_indices = [fill(1, length(tokens) + 2);] sample = (tok = token_indices, segment = segment_indices) bert_embedding = sample |> bert_model.embed collect(sum(bert_embedding, dims=2)[:]) end

vectorize . :

 using Distances x1 = vectorize("Some test about computers") x2 = vectorize("Some test about printers") cosine_dist(x1, x2)

, wordpiece , tokenizer — . 12 — . 768 — . . https://chengchingwen.imtqy.com/Transformers.jl/dev/pretrain/ . , Transformers.Pretrain.@pretrain_str, pretrain"model-description:item" .

, , Transformers.jl , .

निष्कर्ष

, , Julia . . , , . , Julia , . , Julia.

, , , - «», . , , «open source» , , , . , , Julia . , Jupyter Notebook , , — Atom/Juno, VS Code, . , , Julia — 2-3 , ( , , ), C++ .

, , Julia, -, . , , , , . , 2-3 , , . Julia . - , for . — « ». , C, . Julia, , - , , — Julia-. , Julia — , .

, , Julia . , , .

, - Julia — @JuliaLanguage, .

जूलिया एनएलपी। हम ग्रंथों की प्रक्रिया करते हैं