जूलिया और वितरण शब्दार्थ

जूलिया भाषा की दुनिया में अंतिम प्रकाशन के बाद से, बहुत सारी दिलचस्प बातें हुईं:

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

इसी समय, डेवलपर्स से ब्याज में उल्लेखनीय वृद्धि हुई है, जो प्रचुर बेंचमार्किंग द्वारा व्यक्त की गई है:

• अंतर्राष्ट्रीय ऊर्जा एजेंसी चेक पैकेजों को कार्यान्वित करते हुए बहुआयामी अनुकूलन लागू करती है
• Datasayantists GPU के साथ काम का परीक्षण करते हैं
• नहीं थोड़ा सा पक्षपाती लोग अंतर के लिए इंटीग्रेटर्स की तुलना करते हैं
• और उत्साही लोग बुनियादी कार्यों पर भाषाओं की तुलना करते हैं ।

हम नए और सुविधाजनक उपकरणों का आनंद लेते हैं और उनका अध्ययन करना जारी रखते हैं। आज रात को पाठ विश्लेषण के लिए समर्पित किया जाएगा, शेक्सपियर और जूलिया प्रोग्रामर की भावना में राष्ट्रपतियों के भाषणों और पाठ पीढ़ी में छिपे अर्थ की खोज, और मिठाई के लिए, हम 40,000 पाई के आवर्ती नेटवर्क को खिलाते हैं।

हाल ही में यहाँ पर जूलिया के लिए संकुल की समीक्षा को एनएलपी - जूलरी एनएलपी - के क्षेत्र में शोध करने की अनुमति दी गई । हम ग्रंथों की प्रक्रिया करते हैं । तो चलिए तुरंत व्यापार के लिए नीचे आते हैं और TextAnalysis पैकेज के साथ शुरू करते हैं।

TextAnalisys

कुछ पाठ दिए जाएं, जिसे हम एक स्ट्रिंग दस्तावेज़ के रूप में दर्शाते हैं:

using TextAnalysis str = """ Ich mag die Sonne, die Palmen und das Meer, Ich mag den Himmel schauen, den Wolken hinterher. Ich mag den kalten Mond, wenn der Vollmond rund, Und ich mag dich mit einem Knebel in dem Mund. """; sd = StringDocument(str) 

 StringDocument{String}("Ich mag die ... dem Mund.\n", TextAnalysis.DocumentMetadata(Languages.Default(), "Untitled Document", "Unknown Author", "Unknown Time")) 

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

 title!(sd, "Knebel") prepare!(sd, strip_punctuation) remove_case!(sd) text(sd) 

 "ich mag die sonne die palmen und das meer \nich mag den himmel schauen den wolken hinterher \nich mag den kalten mond wenn der vollmond rund \nund ich mag dich mit einem knebel in dem mund \n" 

जो आपको शब्दों के लिए अशुद्ध एन-ग्राम बनाने की अनुमति देता है:

 dict1 = ngrams(sd) Dict{String,Int64} with 26 entries: "dem" => 1 "himmel" => 1 "knebel" => 1 "der" => 1 "schauen" => 1 "mund" => 1 "rund" => 1 "in" => 1 "mond" => 1 "dich" => 1 "einem" => 1 "ich" => 4 "hinterher" => 1 "wolken" => 1 "den" => 3 "das" => 1 "palmen" => 1 "kalten" => 1 "mag" => 4 "sonne" => 1 "vollmond" => 1 "die" => 2 "mit" => 1 "meer" => 1 "wenn" => 1 "und" => 2 

यह स्पष्ट है कि पूंजी अक्षरों के साथ विराम चिह्न और शब्द शब्दकोश में अलग-अलग इकाइयाँ होंगी, जो हमारे पाठ के विशिष्ट शब्दों की आवृत्ति घटनाओं के गुणात्मक मूल्यांकन में हस्तक्षेप करेगी, इसलिए हमने उनसे छुटकारा पा लिया। एन-ग्राम के लिए, कई दिलचस्प अनुप्रयोगों को ढूंढना आसान है, उदाहरण के लिए, उनका उपयोग पाठ में खोज को धूमिल करने के लिए किया जा सकता है, लेकिन चूंकि हम सिर्फ पर्यटक हैं, हम खिलौना उदाहरणों के साथ प्राप्त करेंगे, अर्थात् मार्कोव श्रृंखलाओं का उपयोग करके पाठ की पीढ़ी

प्रोच्ज़ेनि मॉडलोवेहो ग्राफ्टु

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

स्ट्रिंग "एबीएबीडी" के लिए मार्कोव श्रृंखला

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

पाठ को टोकन में तोड़ना (उदा। शब्द)

 using Markovify, Markovify.Tokenizer tokens = tokenize(str, on = words) 2-element Array{Array{String,1},1}: ["Ich", "mag", "die", "Sonne,", "die", "Palmen", "und", "das", "Meer,", "Ich", "mag", "den", "Himmel", "schauen,", "den", "Wolken", "hinterher."] ["Ich", "mag", "den", "kalten", "Mond,", "wenn", "der", "Vollmond", "rund,", "Und", "ich", "mag", "dich", "mit", "einem", "Knebel", "in", "dem", "Mund."] 

हम पहले क्रम का मॉडल बनाते हैं (केवल निकटतम पड़ोसियों को ध्यान में रखा जाता है):

 mdl = Model(tokens; order=1) Model{String}(1, Dict(["dich"] => Dict("mit" => 1),["den"] => Dict("Himmel" => 1,"kalten" => 1,"Wolken" => 1),["in"] => Dict("dem" => 1),["Palmen"] => Dict("und" => 1),["wenn"] => Dict("der" => 1),["rund,"] => Dict("Und" => 1),[:begin] => Dict("Ich" => 2),["Vollmond"] => Dict("rund," => 1),["die"] => Dict("Sonne," => 1,"Palmen" => 1),["kalten"] => Dict("Mond," => 1)…)) 

फिर हम प्रदान किए गए मॉडल के आधार पर उत्पन्न वाक्यांश के कार्य को लागू करने के लिए आगे बढ़ते हैं। वास्तव में, यह एक मॉडल, वर्कअराउंड, और उन वाक्यांशों की संख्या है जो आप प्राप्त करना चाहते हैं:

 function gensentences(model, fun, n) sentences = [] # Stop only after n sentences were generated # and passed through the length test while length(sentences) < n seq = fun(model) # Add the sentence to the array iff its length is ok if length(seq) > 3 && length(seq) < 20 push!(sentences, join(seq, " ")) end end sentences end 

पैकेज के डेवलपर ने दो बाईपास फ़ंक्शन प्रदान किए: walk और walk walk2 (दूसरा लंबे समय तक काम करता है, लेकिन अधिक अद्वितीय डिजाइन देता है), और आप हमेशा अपना विकल्प निर्धारित कर सकते हैं। आइए इसे आजमाएँ:

 gensentences(mdl, walk, 4) 4-element Array{Any,1}: "Ich mag den Wolken hinterher." "Ich mag die Palmen und das Meer, Ich mag den Himmel schauen, den Wolken hinterher." "Ich mag den Wolken hinterher." "Ich mag die Palmen und das Meer, Ich mag dich mit einem Knebel in dem Mund." gensentences(mdl, walk2, 4) 4-element Array{Any,1}: "Ich mag den Wolken hinterher." "Ich mag dich mit einem Knebel in dem Mund." "Ich mag den Himmel schauen, den kalten Mond, wenn der Vollmond rund, Und ich mag den Wolken hinterher." "Ich mag die Sonne, die Palmen und das Meer, Ich mag dich mit einem Knebel in dem Mund." 

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

अपनी बहन की सलाह पर, विशेष पात्रों और किसी भी विभाजकों से ओस्टर की पुस्तकों की एक जोड़ी को साफ करने और एन-ग्राम के लिए दूसरा आदेश सेट करने पर, मुझे वाक्यांशगत इकाइयों का निम्नलिखित सेट मिला:

  ",             !" ".   , :    !" ",   , , ,       ?" "      !" ".     ,     !" ".  ,       ?" "    ,         !" "      ?" " ,   ,       ?" "     ?" ",      .     ?" 

उसने विश्वास दिलाया कि यह एक ऐसी तकनीक है जिससे महिला मस्तिष्क में विचारों का निर्माण किया गया है ... अहम, और मैं कौन हूँ बहस करने के लिए ...

इसका विश्लेषण कीजिए

TextAnalysis पैकेज की निर्देशिका में आप पाठ डेटा के उदाहरण पा सकते हैं, जिनमें से एक कांग्रेस के पहले अमेरिकी राष्ट्रपतियों द्वारा भाषणों का संग्रह है

 using TextAnalysis, Clustering, Plots#, MultivariateStats pth = "C:\\Users\\User\\.julia\\packages\\TextAnalysis\\pcFQf\\test\\data\\sotu" files = readdir(pth) 

 29-element Array{String,1}: "Bush_1989.txt" "Bush_1990.txt" "Bush_1991.txt" "Bush_1992.txt" "Bush_2001.txt" "Bush_2002.txt" "Bush_2003.txt" "Bush_2004.txt" "Bush_2005.txt" "Bush_2006.txt" "Bush_2007.txt" "Bush_2008.txt" "Clinton_1993.txt" ⋮ "Clinton_1998.txt" "Clinton_1999.txt" "Clinton_2000.txt" "Obama_2009.txt" "Obama_2010.txt" "Obama_2011.txt" "Obama_2012.txt" "Obama_2013.txt" "Obama_2014.txt" "Obama_2015.txt" "Obama_2016.txt" "Trump_2017.txt" 

इन फ़ाइलों को पढ़ने और उनसे एक वाहिनी बनाने के साथ-साथ विराम चिह्न से इसे साफ करने के बाद, हम सभी भाषणों की सामान्य शब्दावली की समीक्षा करेंगे:

 crps = DirectoryCorpus(pth) standardize!(crps, StringDocument) crps = Corpus(crps[1:29]); 

 remove_case!(crps) prepare!(crps, strip_punctuation) update_lexicon!(crps) update_inverse_index!(crps) lexicon(crps) 

 Dict{String,Int64} with 9078 entries: "enriching" => 1 "ferret" => 1 "offend" => 1 "enjoy" => 4 "limousines" => 1 "shouldn" => 21 "fight" => 85 "everywhere" => 17 "vigilance" => 4 "helping" => 62 "whose" => 22 "'" => 725 "manufacture" => 3 "sleepless" => 2 "favor" => 6 "incoherent" => 1 "parenting" => 2 "wrongful" => 1 "poised" => 3 "henry" => 3 "borders" => 30 "worship" => 3 "star" => 10 "strand" => 1 "rejoin" => 3 ⋮ => ⋮ 

यह देखना दिलचस्प हो सकता है कि कौन से दस्तावेज़ में विशिष्ट शब्द हैं, उदाहरण के लिए, इस बात पर एक नज़र डालें कि हम वादों से कैसे निपटते हैं:

 crps["promise"]' 1×24 LinearAlgebra.Adjoint{Int64,Array{Int64,1}}: 1 2 3 4 6 7 9 10 11 12 15 … 21 22 23 24 25 26 27 28 29 crps["reached"]' 1×7 LinearAlgebra.Adjoint{Int64,Array{Int64,1}}: 12 14 15 17 19 20 22 

या सर्वनाम आवृत्तियों के साथ:

 lexical_frequency(crps, "i"), lexical_frequency(crps, "you") (0.010942182388035081, 0.005905479339070189) 

तो शायद वैज्ञानिकों और पत्रकारों का बलात्कार और अध्ययन किए जा रहे आंकड़ों के प्रति विकृत रवैया है।

Matematritsy

सच में वितरणात्मक शब्दार्थ तब शुरू होता है जब ग्रंथ, ग्राम और टोकन वैक्टर और मैट्रिस में बदल जाते हैं।

एक दस्तावेज़ दस्तावेज़ मैट्रिक्स ( DTM ) एक मैट्रिक्स है जिसका आकार होता है $$$एन \ _ डब्लू$जहाँ $$$एन$- मामले में दस्तावेजों की संख्या, और $$$डब्ल्यू$- कॉर्पस डिक्शनरी का आकार यानी शब्दों की संख्या (अद्वितीय) जो हमारे कॉर्पस में पाए जाते हैं। I- th पंक्ति में, मैट्रिक्स का j- th कॉलम एक संख्या है - i- th पाठ में कितनी बार j- th शब्द मिला।

 dtm1 = DocumentTermMatrix(crps) 

 D = dtm(dtm1, :dense) 29×9078 Array{Int64,2}: 0 0 1 4 0 0 0 0 0 0 0 0 0 … 1 0 0 16 0 0 0 0 0 0 0 1 4 0 0 0 0 0 0 0 0 0 1 0 0 4 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 3 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 5 8 0 0 0 0 0 0 0 0 0 0 0 0 10 38 0 0 0 0 0 3 0 0 0 0 0 0 0 0 5 0 … 0 0 0 22 0 0 0 0 0 0 0 12 4 2 0 0 0 0 0 1 3 0 0 0 0 41 0 0 0 0 0 0 0 1 1 2 1 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 44 0 0 0 0 0 0 0 2 1 1 0 0 0 0 0 0 2 0 0 0 67 0 0 14 1 1 31 2 0 8 2 1 1 0 0 0 0 0 4 0 … 0 0 0 50 0 0 0 0 0 2 0 3 3 0 2 0 0 0 0 0 2 1 0 0 0 11 0 0 0 0 0 0 0 8 3 6 3 0 0 0 0 0 0 0 1 0 0 4 0 0 0 0 0 ⋮ ⋮ ⋮ ⋱ ⋮ ⋮ 0 1 11 5 3 3 0 0 0 1 0 1 0 1 0 0 44 0 0 0 0 0 0 0 11 5 4 5 0 0 0 0 0 1 0 1 0 0 48 0 0 0 0 0 0 0 18 6 8 4 0 0 0 0 0 0 1 1 0 0 80 0 0 0 0 0 0 0 1 2 0 0 0 0 0 0 0 0 0 … 0 0 0 26 0 0 0 0 0 1 0 4 5 5 1 0 0 0 0 0 1 0 0 0 45 0 0 0 0 0 1 1 0 8 2 1 3 0 0 0 0 0 2 0 0 0 47 0 0 170 11 11 1 0 0 7 1 1 1 0 0 0 0 0 0 0 0 0 3 2 0 208 2 2 0 1 0 5 2 0 1 1 0 0 0 0 1 0 0 0 41 0 0 122 7 7 1 0 0 4 3 4 1 0 0 0 0 0 0 0 … 0 0 62 0 0 173 11 11 7 2 0 6 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 3 0 3 0 0 0 0 0 0 0 0 0 0 0 35 0 0 0 0 0 1 0 2 2 0 2 0 0 0 0 0 1 0 0 0 0 30 0 0 0 0 0 

यहाँ मूल इकाइयाँ शब्द हैं

 m.terms[3450:3465] 16-element Array{String,1}: "franklin" "frankly" "frankness" "fraud" "frayed" "fraying" "fre" "freak" "freddie" "free" "freed" "freedom" "freedoms" "freely" "freer" "frees" 

एक पल रुकिए ...

 crps["freak"] 1-element Array{Int64,1}: 25 files[25] "Obama_2013.txt" 

इसे और अधिक विस्तार से पढ़ना आवश्यक होगा ...

आप शब्द मैट्रिक्स से सभी प्रकार के दिलचस्प डेटा भी निकाल सकते हैं। दस्तावेजों में विशिष्ट शब्दों की घटना की आवृत्ति कहें

 w1, w2 = dtm1.column_indices["freedom"], dtm1.column_indices["terror"] (3452, 8101) 

 D[:, w1] |> bar 

 D[:, w1] |> bar 

या कुछ छिपे हुए विषयों पर दस्तावेजों की समानता:

 k = 3 #     iterations = 1000 # number of gibbs sampling iterations α = 0.1 # hyper parameter β = 0.1 # hyper parameter # Latent Dirichlet Allocation ϕ, θ = lda(m, k, iterations, α, β) # Latent Dirichlet Allocation plot(θ', line = 3) 

रेखांकन दिखाते हैं कि भाषणों में तीन विषयों में से प्रत्येक का कैसे खुलासा किया गया है

या विषय के आधार पर शब्द , या उदाहरण के लिए, शब्दावली की समानता और विभिन्न दस्तावेजों में कुछ विषयों की प्राथमिकता

 T = tf_idf(D) cl = kmeans(T, 5) #   assign = assignments(cl) #       clc = cl.centers #   clsize = counts(cl) #   5-element Array{Int64,1}: 1 1784 36 1 7280 

 s1 = scatter(T[10, 1:10:end], assign, yaxis = "Bush 2006") s2 = scatter(T[29, 1:10:end], assign, yaxis = "Obama 2016") s3 = scatter(T[30, 1:10:end], assign, yaxis = "Trump 2017") plot(s1, s2, s3, layout = (3,1), legend=false ) 

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

ठीक है, इसलिए बहुत दूर नहीं जाना चाहिए, हम आदर्श राष्ट्रपति के लिए वाक्यांश उत्पन्न करेंगे:

 function loadfiles(filenames) return ( open(filename) do file text = read(file, String) # Tokenize on words (we could also tokenize on letters/lines etc.) # That means: split the text to sentences and then those sentences to words tokens = tokenize(text; on=letters) return Model(tokens; order=N) end for filename in filenames ) end pth = "C:\\Users\\User\\.julia\\packages\\TextAnalysis\\pcFQf\\test\\data\\sotu" FILENAMES = readdir(pth) N = 1 MODEL = combine(loadfiles(FILENAMES)...) gensentences(MODEL, walk2, 7) 

 7-element Array{Any,1}: "I want harmony and fathers, sons and we mark the jobkilling TransPacific Partnership." "I am asking all across our partners must be one very happy, indeed." "At the health insurance and terrorismrelated offenses since my Inauguration, and the future and pay their jobs, their community." "Millions lifted from this Nation, and Jessica Davis." "It will expand choice, increase access, lower the Director of our aspirations, not working." "We will defend our freedom." "The challenges we will celebrate the audience tonight, has come for a record." 

दीर्घकालीन स्मृति

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

• उदाहरणों ने भावुकता की पहचान करने के लिए भाषण के कुछ हिस्सों में मार्कअप से - फ्लक्स का उपयोग किया
• आरएनएन टू फ्लक्स
• केनेट में आर.एन.एन.
• LSTM और रूसी संस्करण के बारे में लेख
• TPU नेट

पुनरावृत्ति नेटवर्क के संचालन के विशिष्ट उदाहरणों में से एक अक्सर मॉडल है कि शेक्सपियर के सोननेट्स को प्रतीकात्मक रूप से खिलाया जाता है:

 QUEN: Chiet? The buswievest by his seld me not report. Good eurronish too in me will lide upon the name; Nor pain eat, comes, like my nature is night. GRUMIO: What for the Patrople: While Antony ere the madable sut killing! I think, bull call. I have what is that from the mock of France: Then, let me? CAMILLE: Who! we break be what you known, shade well? PRINCE HOTHEM: If I kiss my go reas, if he will leave; which my king myself. BENEDICH: The aunest hathing rouman can as? Come, my arms and haste. This weal the humens? Come sifen, shall as some best smine? You would hain to all make on, That that herself: whom will you come, lords and lafe to overwark the could king to me, My shall it foul thou art not from her. A time he must seep ablies in the genely sunsition. BEATIAR: When hitherdin: so like it be vannen-brother; straight Edwolk, Wholimus'd you ainly. DUVERT: And do, still ene holy break the what, govy. Servant: I fearesed, Anto joy? Is it do this sweet lord Caesar: The dece वह छोड़ देंगे; QUEN: Chiet? The buswievest by his seld me not report. Good eurronish too in me will lide upon the name; Nor pain eat, comes, like my nature is night. GRUMIO: What for the Patrople: While Antony ere the madable sut killing! I think, bull call. I have what is that from the mock of France: Then, let me? CAMILLE: Who! we break be what you known, shade well? PRINCE HOTHEM: If I kiss my go reas, if he will leave; which my king myself. BENEDICH: The aunest hathing rouman can as? Come, my arms and haste. This weal the humens? Come sifen, shall as some best smine? You would hain to all make on, That that herself: whom will you come, lords and lafe to overwark the could king to me, My shall it foul thou art not from her. A time he must seep ablies in the genely sunsition. BEATIAR: When hitherdin: so like it be vannen-brother; straight Edwolk, Wholimus'd you ainly. DUVERT: And do, still ene holy break the what, govy. Servant: I fearesed, Anto joy? Is it do this sweet lord Caesar: The dece 

यदि आप अंग्रेजी नहीं जानते हैं और यह नाटक काफी वास्तविक है ।

रूसी में समझना आसान है

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

डेटा संग्रह

Pies और पाउडर - लयबद्ध quatrains, अक्सर कविता के बिना, कम मामले में टाइप किए गए और विराम चिह्न के बिना।

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

• HTTP.jl - जूलिया के लिए HTTP क्लाइंट और सर्वर कार्यक्षमता
• Gumbo.jl - html- लेआउट को पार्स करना और न केवल
• Cascadia.jl - गुमबो के लिए सहायक पैकेज

फिर हम एक स्क्रिप्ट को लागू करते हैं जो कविता के पन्नों को बदल देती है और एक पाठ दस्तावेज़ में pies को बचाता है:

 using HTTP, Gumbo, Cascadia function grabit(npages) str = "" for i = 1:npages url = "https://poetory.ru/por/rating/$i" # https://poetory.ru/pir/rating/$i res = HTTP.get(url) body1 = String(res.body) htmlka = parsehtml(body1) qres = eachmatch(sel".item-text", htmlka.root) for elem in qres str *= (elem[1].text * "\n\n") end print(i, ' ') end f = open("poroh.txt","w") write(f, str) close(f) end grabit(30) 

अधिक विस्तार से, यह एक बृहस्पति नोटबुक में विस्थापित है । चलो एक ही पंक्ति में पाई और बारूद इकट्ठा करते हैं:

 str = read("pies.txt", String) * read("poroh.txt", String); length(str) # 7092659 

और इस्तेमाल की गई वर्णमाला को देखें:

 prod(sort([unique(str)..., '_']) ) # "\n !\"#\$&'()*+,-./012345678:<>?@ABCDEFGHIKLMNOPQRSTUV[]^__abcdefghijklmnopqrstuvwxyz«\uad°º»¾¿ÐÑßàáãäåæçèéêëìíîðñóõöùûüýþÿıņōŏƍǝǹɐɓɔɯɹʁʎʚʞ́εєіїўѣҺאבהוחטיךלםמעףצקרשתئاةتجدرزسعكلمنهوپچڑکگںھہیے  \u200b–—…€║╛╨█□ \ufeff" 

प्रक्रिया शुरू करने से पहले डाउनलोड किए गए डेटा की जांच करें।

अय-आह-आह, क्या अपमान! कुछ उपयोगकर्ता नियमों को तोड़ते हैं (कभी-कभी लोग इन आंकड़ों में शोर करके खुद को व्यक्त करते हैं)। इसलिए हम अपने प्रतीक मामले को कचरे से साफ करेंगे

 str = lowercase(str) #    #      str = replace(str, r"|" => s"" ); #   str = replace(str, r" | | " => " "); #     str = replace(str, r"[!-]|[ѐ-\u2714]|\ufeff" => "") alstr = str |> unique |> sort |> prod #alstr = prod(sort(unique(str)) ) #  # "\n " 

जैसा कि rssdev10 द्वारा सलाह दी गई है , नियमित अभिव्यक्ति का उपयोग करके कोड को संशोधित किया गया है

अधिक स्वीकार्य वर्ण सेट मिला। आज का सबसे बड़ा रहस्योद्घाटन यह है कि, मशीन कोड के दृष्टिकोण से, कम से कम तीन अलग-अलग स्थान हैं - यह डेटा शिकारी के रहने के लिए कठिन है।

अब आप फ्लक्स को डेटा के बाद की प्रस्तुति के साथ एक वॉट्स वैक्टर के रूप में जोड़ सकते हैं:

 using Flux using Flux: onehot, chunk, batchseq, throttle, crossentropy using StatsBase: wsample using Base.Iterators: partition texta = collect(str) println(length(texta)) # 7086899 alphabet = [unique(texta)..., '_'] texta = map(ch -> onehot(ch, alphabet), texta) stopa = onehot('_', alphabet) println(length(alphabet)) # 34 N = length(alphabet) seqlen = 128 nbatch = 128 Xs = collect(partition(batchseq(chunk(texta, nbatch), stopa), seqlen)) Ys = collect(partition(batchseq(chunk(texta[2:end], nbatch), stopa), seqlen)); 

हम मॉडल को LSTM परतों के एक जोड़े से, एक पूरी तरह से जुड़ा हुआ परसेप्ट्रॉन और सॉफ्टमैक्स, साथ ही रोजमर्रा की छोटी चीजें, और नुकसान फ़ंक्शन और अनुकूलक के लिए सेट करते हैं:

 m = Chain( LSTM(N, 256), LSTM(256, 128), Dense(128, N), softmax) # m = gpu(m) function loss(xs, ys) l = sum(crossentropy.(m.(gpu.(xs)), gpu.(ys))) Flux.truncate!(m) return l end opt = ADAM(0.01) tx, ty = (Xs[5], Ys[5]) evalcb = () -> @show loss(tx, ty) 

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

 @time Flux.train!(loss, params(m), zip(Xs, Ys), opt, cb = throttle(evalcb, 30)) 

एक नमूना जनरेटर को इकट्ठा करने के बाद, आप अपने मजदूरों के लाभों को प्राप्त करना शुरू कर सकते हैं।

 function sample(m, alphabet, len) #m = cpu(m) Flux.reset!(m) buf = IOBuffer() c = rand(alphabet) for i = 1:len write(buf, c) c = wsample(alphabet, m( onehot(c, alphabet) ).data ) end return String(take!(buf)) end sample(m, alphabet, 1000) |> println 

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

एक प्रशिक्षित नेटवर्क का वजन डिस्क में सहेजा जा सकता है, और फिर आसानी से पढ़ा जा सकता है

 weights = Tracker.data.(params(model)); using BSON: @save # https://github.com/JuliaIO/BSON.jl @save "Pies_34x128.bson" weights #     : using BSON: @load @load "mymodel1.bson" weights Flux.loadparams!(m, weights) 

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

         !     . ? ,    ,                ,   ,        ,  ,   ,     ,                      .           , ,      ,         ,       .            ,         . ? , ,  ,   ,       ,  ,    

लेकिन अगर आप जूलिया भाषा के स्रोत कोड पर एक तंत्रिका नेटवर्क को प्रशिक्षित करते हैं, तो यह बहुत अच्छा निकलता है:

  # optional _ = Expr(expMreadcos, Expr(:meta, :stderr), :n, :default, ex, context[oeex, ex.args[1] -typeinfo + Int]) isprint((v), GotoNode(e)) end for (fname, getfield) do t print(io, ":") new() end end if option quote bounds end end @sprintf("Other prompt", ex.field, UV_REQ) == pop!(bb_start_off+1, i) write(io, take!(builder_path)) end Base.:Table(io::IOContext) = write(io, position(s)) function const_rerror(pre::GlobalRef) ret = proty(d) if !rel_key && length(blk) return htstarted_keys(terminal(u, p)) end write(io, ("\\\\" => "\n\n\n\n") ? "<username>\n>\n" p = empty(dir+stdout) n = MD(count_ok_new_data(L) : n_power while push!(blks[$ur], altbuf) end function prec_uninitual(p, keep='\n') print(io, "1 2") else p = blk + p0 out = Mair(1) elseif occursin(".cmd", keep=ks) != 0 res = write(io, c) end while take!(word) 

इसे मेटाप्रोग्रामिंग की संभावना से जोड़ा जाता है, हमें एक प्रोग्राम मिलता है जो लिखता है और चलता है, शायद हमारा अपना कोड भी! खैर, या यह हैकर्स के बारे में फिल्म डिजाइनरों के लिए एक गॉडसेंड होगा।

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

इस पर, मैं अपनी छुट्टी ले लूं। क्लाउड में प्रशिक्षण के लिए डेटा, गीथूब पर लिस्टिंग, आंखों में आग, बतख में एक अंडा और सभी को शुभ रात्रि!