🏺 ✊ 🛀🏼 अपनी परियोजनाओं में टॉमिता-पार्सर का उपयोग कैसे करें। प्रैक्टिकल कोर्स 🤙🏼 🚵🏿 🍙

नमस्ते, मेरा नाम नताल्या है, मैं तथ्य निष्कर्षण समूह में एक डेवलपर के रूप में यांडेक्स में काम करता हूं। वसंत में, हमने इस बारे में बात की कि टॉमेटा पार्सर क्या है और इसका इस्तेमाल यैंडेक्स में क्या किया जाता है। और पहले से ही यह गिरावट पार्सर के स्रोत कोड को सार्वजनिक डोमेन में पोस्ट किया जाएगा।

पिछली पोस्ट में, हमने पार्सर और इसकी आंतरिक भाषा के सिंटैक्स का उपयोग करने के तरीके के बारे में बात करने का वादा किया था। यह मेरी आज की कहानी है।

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

व्याकरण नियमों का एक समूह है जो एक पाठ में शब्दों की एक स्ट्रिंग का वर्णन करता है। उदाहरण के लिए, यदि हमारे पास "मुझे पसंद है कि आप मेरे साथ बीमार नहीं हैं", तो यह निम्नलिखित श्रृंखला [पहला सर्वनाम, एकवचन], [वर्तमान काल और तीसरे व्यक्ति], [अल्पविराम], [संघ] का उपयोग करके वर्णित किया जा सकता है। आदि

व्याकरण एक विशेष औपचारिक भाषा में लिखा जाता है। संरचनात्मक रूप से, नियम को प्रतीक द्वारा विभाजित किया गया है ->

बाएं और दाएं भागों में। बाईं ओर एक गैर-थर्मल है, और दाएं में टर्मिनलों और गैर-टर्मिनलों दोनों शामिल हैं। इस संदर्भ में एक टर्मिनल एक वस्तु है जिसका एक विशिष्ट, अपरिवर्तनीय मूल्य है। कई टर्मिनल टॉमिता भाषा की वर्णमाला हैं, जहाँ से अन्य सभी शब्दों का निर्माण किया जाता है। टोमाइट में शब्द 'लेम्मास' हैं - एकल उद्धरणों में लिखे गए प्रारंभिक शब्द, ( Noun, Verb, Adj

...), विराम चिह्न ( Comma, Punct, Hyphen

...) और कुछ अन्य विशेष वर्ण ( Percent, Dollar

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

और Noun

मिलकर, दो शब्दों की एक श्रृंखला का अर्थ है: पहले एक विशेषण, फिर एक संज्ञा।

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

 #encoding "utf8"

फिर आप नियम लिख सकते हैं। हमारे पहले व्याकरण में उनमें से दो होंगे:

 PP -> Prep Noun; S -> Verb PP;

पहला नियम नॉनटर्मिनल PP

वर्णन करता है - एक प्रीपोजल समूह जिसमें एक प्रीपोजिशन और एक संज्ञा ( Prep Noun

) होता है। दूसरा नियम एक क्रिया है जिसमें एक पूर्वपद समूह ( Verb PP

) होता है। इस मामले में, nonterminal S

जड़ है क्योंकि यह नियम के दाईं ओर कभी उल्लेख नहीं किया गया है। इस गैर-टर्मिनल को पेड़ का शीर्ष कहा जाता है। यह पूरी श्रृंखला का वर्णन करता है जिसे हम पाठ से निकालना चाहते हैं।

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

 encoding "utf8";

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

 import "base.proto"; import "article_base.proto";

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

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

), और इस फ़ाइल का पथ, फिर type

फ़ील्ड में - कुंजी का प्रकार (यह निर्दिष्ट किया जाना चाहिए कि कुंजी में व्याकरण का लिंक है)।

 TAuxDicArticle "_" { key = {"tomita:first_grammar.cxx" type=CUSTOM} }

पार्सर को यह बताने के लिए कि हमें स्रोत पाठ कहां से प्राप्त होता है, जहां हम परिणाम लिखते हैं, हम कौन से व्याकरण लॉन्च करते हैं, हम कौन से तथ्य निकालते हैं, साथ ही अन्य आवश्यक जानकारी, एक्सटेंशन के साथ एक एकल कॉन्फ़िगरेशन फ़ाइल बनाई जाती है। पार्सर फ़ोल्डर में config.proto फ़ाइल बनाएँ। हमेशा की तरह, शुरुआत में हम एन्कोडिंग को इंगित करते हैं और हमारे कॉन्फ़िगरेशन के विवरण के लिए आगे बढ़ते हैं।

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

फ़ील्ड में है। टेक्स्ट फ़ाइलों के अलावा, टोमाइट को इनपुट फ़ोल्डर, आर्काइव या स्टडिन में जमा किया जा सकता है। Output

फ़ील्ड रिकॉर्ड करता है कि कहाँ और किस प्रारूप में (पाठ, xml या प्रोटोबॉफ़) निकाले गए तथ्यों को सहेजा जाना चाहिए। हम input.txt फाइल को इनपुट पर भेज देंगे। Articles

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

 encoding "utf8"; TTextMinerConfig { Dictionary = "dic.gzt"; Input = {File = "input.txt"} Output = {File = "output.txt" Format = text} Articles = [ { Name = "_" } ] }

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

 ./tomitaparser config.proto

परिणाम output.txt फ़ाइल में मिल सकते हैं। हालाँकि, हम वहां कोई भी निकाले गए तथ्य नहीं देखेंगे, क्योंकि अभी तक हमारे व्याकरण में केवल श्रृंखलाओं के चयन के नियम हैं, और चयनित श्रृंखलाओं के लिए संरचित तथ्यों में बदलने के लिए, हमें एक व्याख्या प्रक्रिया जोड़ने की आवश्यकता है। हम इसके बारे में थोड़ी कम बात करेंगे। हालाँकि, हम पहले से ही इस स्तर पर चयनित श्रृंखला देख सकते हैं, इसके लिए हमें कॉन्फ़िगरेशन फ़ाइल में एक और पैरामीटर जोड़ने की आवश्यकता है - डिबग आउटपुट:

 PrettyOutput = "pretty.html"

इस पैरामीटर के लिए धन्यवाद, पार्सर के परिणामों को अधिक दृश्य प्रतिनिधित्व के साथ HTML-फ़ाइल में लिखा जाएगा। अब, यदि हम व्याकरण को पुनः आरंभ करते हैं और फोल्डर में दिखाई देने वाली pretty.html फ़ाइल को खोलते हैं, तो हम देखेंगे कि हमने व्याकरण में हमारे द्वारा वर्णित सभी श्रृंखलाओं को पुनः प्राप्त कर लिया है - क्रिया जिसके बाद संज्ञा पूर्वसर्ग के साथ आती है:

परिणाम

दूत की सवारी

दुआ के पास रहना

रात भर के लिए रुकें

उसके पास जाओ

Stavropol पर जाएं

साथ चलो

वोदका ले लो

लाइन पर आओ

हाइलैंडर्स के खिलाफ रखा

तीसरे में रेककन

दिन का पालन करें

दक्षिण में होना

ऊपर जाना

घाटी में वापस देखो

मांग वोदका

मुख्यालय के कप्तान को देखो

एक गाय पर ठोकर

आग से आश्रय

चेचन्या में होना

शाफ्ट पर ले जाएँ

एक सूटकेस से बाहर खींचो

अफसोस

सामने से पहले निकल जाओ

पर मुकदमा चलाया

दूर रहो

किले में खड़े हो जाओ

एक किले में बसना

एक सूअर पर जाने के लिए

हंसो

इसमें होना है

पैसे के लिए हो

ताली बजाते हैं

इसे देखो

मालिक के पीछे दौड़ो

सकला बनो

बाहर हवा में जाओ

पहाड़ों पर जाओ

बाड़ के साथ उतारा

तेरे पीछे हो

abreks के साथ सवारी

स्टंप पर कूदो

वेकेशन में दौड़ें

मोर्चे पर लटकाओ

एक खड्ड में उड़ना

मार डालना

स्टेपनी तक पहुँचें

किनारे से दौड़ो

खुरों से उड़ना

अंधेरे में चमकना

चेन मेल करने के लिए चिपटना

जंगल की बाड़ को मारो

स्थिर हो जाना

एक बंदूक ले लो

भीड़ के बीच कताई

एक अजनबी में होना

कुछ और बात करो

प्यार से आओ

औल में कूदो

गढ़ छोड़ दो

चेहरा बदलो

एक बंदूक पर कूदो

एक उत्साही पर सवारी

मामले से पकड़ो

जमीन पर गिरना

किले में आना

उस पर सरपट दौड़ना

औल जाना

उसके पास जाओ

एक मृत अंत में हो

कोने में बैठो

कैद में डूबना

खिड़की से बाहर देखो

एक सोफे पर बैठो

उसके पास जाओ

हाथ मिलाओ

दरार करने में सक्षम हो

एक सपने में सपना

सड़क से प्रतीक्षा करें

शाम को होना

झाड़ी से गोता लगाना

पहाड़ी से देखें

बर्फ में कंपकंपी

झोपड़ी से बाहर निकलो

के रूप में बाहर जाओ

बंद करना

अपनी ताकत खो दो

स्वर्ग के लिए नेतृत्व

बादल में गायब हो जाना

शीर्ष पर आराम करो

क्रंच अंडरफुट

सर में घुस जाना

दिल से दूर हो जाना

हुड पहाड़ चढ़ो

विकिरण से दूर हो जाओ

हुड पहाड़ों नीचे जाओ

शब्द से आते हैं

अपने पैरों के नीचे गिरो

बर्फ में बदलो

कोहरे में छिप जाना

सलाखों पर हराया

मौसम में बंद करो

वोदका देना

गाल पर जंगली चलाते हैं

मृत्यु की घोषणा करो

जंगली सूअर के लिए धोने के लिए

एक सेर से शादी करो

कमरे के चारों ओर चलो

बिस्तर पर बैठो

पहाड़ों पर खींचें

बिस्तर पर गिरो

सितंबर में हो

सर्फ़ के आसपास चलो

टर्फ ले लो

शाफ़्ट बंद हो

कोने पर बैठो

स्थिर रहो

रकाब पर खड़े हो जाओ

शिकार से लौट आओ

नदी से बाहर हो

शर्त

इसमें बदलाव करें

शिकार करना

देशी के लिए तरस रही

में डाल दिया

हिरासत से बाहर निकलो

अमेरिका जाना

सड़क पर मरो

राजधानी का दौरा करें

पीने से आता है

मुखर होना

नरकट के चारों ओर सूँघना

नरकट में जाना

ढेर

क्षेत्र में इंगित करें

काठी से बाहर चीर

Pechorin के साथ पकड़

झपकी लेना

अपने घुटनों पर गिरो

हाथ पर रखना

एक चट्टान पर चढ़ना

घोड़ों से उतरना

एक घाव से बाहर डालना

स्मृति के बिना हो

उसे संयंत्र

डॉक्टर के लिए भेजें

किले से बाहर निकलो

एक पत्थर पर बैठो

झाड़ियों में खींचें

एक घोड़े पर कूदो

बिस्तर से बैठो

दीवार की ओर मुड़ें

पहाड़ों को चाहते हैं

आत्मा से मिलो

जन्नत में होगा

एक विचार के साथ आओ

उसी में मरो

घुटने टेक दो

सर्फ़ के पास जाओ

दु: ख के साथ मरो

जमीन पर बैठो

त्वचा के माध्यम से चलाएं

किले के पीछे दफनाना

जॉर्जिया जाओ

रूस वापस लौटें

मैक्सिम के साथ हिस्सा

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

अगला चरण एक व्याख्या प्रक्रिया की शुरूआत है, अर्थात्। निकाले गए चेन को तथ्यों में बदलना।

पहले हमें उस तथ्य की संरचना बनाने की आवश्यकता है जिसे हम निकालना चाहते हैं, अर्थात्। वर्णन करें कि इसमें कौन से क्षेत्र शामिल हैं। ऐसा करने के लिए, एक नया fact_types.proto फ़ाइल बनाएं। फिर, हम मूल प्रकारों के साथ फ़ाइलों को आयात करेंगे, और फिर स्वयं तथ्य के विवरण के लिए आगे बढ़ेंगे। शब्द संदेश के बाद तथ्य का नाम, एक बृहदान्त्र और मूल प्रकार का तथ्य लिखा जाता है, जिससे हमारे तथ्य का प्रकार विरासत में मिलता है। अगला, घुंघराले कोष्ठक में, हम अपने तथ्य के क्षेत्रों को सूचीबद्ध करते हैं। हमारे मामले में, फ़ील्ड एक है, यह आवश्यक है (आवश्यक), टेक्स्ट (स्ट्रिंग), जिसे फ़ील्ड 1 कहा जाता है और हम इसे पहचानकर्ता 1 प्रदान करते हैं।

 import "base.proto"; import "facttypes_base.proto"; message Fact: NFactType.TFact { required string Field1 = 1; }

अब हमें उस फ़ाइल को रूट डिक्शनरी (dic.gzt) में आयात करने की आवश्यकता है:

 import "fact_types.proto";

चलो व्याकरण पर चलते हैं, जिसमें व्याख्या प्रक्रिया होती है। मान लीजिए कि हम पाठ से एक तथ्य निकालना चाहते हैं: क्रिया जो एक पूर्वसर्ग के साथ संज्ञा को नियंत्रित करती है। ऐसा करने के लिए, नियम में, क्रिया मार्कर के बाद, हम interp

लिखते हैं, और फिर कोष्ठक में तथ्य का नाम और डॉट के माध्यम से उस क्षेत्र का नाम जिसमें हम निकाले गए चेन डालना चाहते हैं।

  S -> Verb interp (Fact.Field1) PP;

व्याकरण में कहीं भी व्याख्या हो सकती है, लेकिन तथ्य केवल तभी निकाला जाता है जब व्याख्या किया गया चरित्र जड़हीन में गिरता है।

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

फ़ील्ड में, वर्ग ब्रैकेट सभी आवश्यक तथ्यों को सूचीबद्ध करते हैं। हमारे मामले में, केवल एक तथ्य है:

 Facts = [ { Name = "Fact" } ]

अब आप फिर से पार्सर शुरू कर सकते हैं।

परिणाम

जाने के लिए

रोकना

ऊपर आओ

जाने के लिए

धक्का देना

लेने के लिए

आने के लिए

लगाना

माना जाता है

पालन करना

होना है

जाने के लिए

पीछे देखो

मांग करना

देखना

ठोकर खाना

शरण देना

होना है

दूर हटो

बाहर खींचो

पछतावा करना

बाहर जाओ

देने के लिए

होना है

खड़ा होना

बस जाओ

चलना

फाड़ना

होना है

ताली

देखना है

चलाने के लिए

बनने के लिए

बाहर जाओ

सो जाओ

एक रास्ता बनाओ

होना है

सवारी करना

कूदना

चलाने के लिए

पर लटका

उड़ान भरने के लिए

मारने के लिए

पहुँच जाओ

चलाने के लिए

उड़ान भरने के लिए

चमकने के लिए

बजना

हिट

जल्दी करना

पकड़ के लिए आ

चारों ओर घूमना

लगाना

बोलना

होना है

कूद

छोड़ने के लिए

परिवर्तनशील

कूदना

छोड़

छीनना

नीचे गिरना

आने के लिए

सरपट भागना

बंद करना

जाने के लिए

बनने के लिए

बैठने के लिए

दूर होना

में देखने के लिए

बैठने के लिए

बंद करो

हिट करना

सक्षम होना

सपने देखना

इंतजार करना

होना है

गोता लगाना

देखना

ठंडा होने के

बाहर जाओ

बंद करना

खटखटाओ

नेतृत्व करना

गायब हो जाते हैं

आराम करने के लिए

कुचलना

वृद्धि करने के लिए

गिर जाना

ऊपर चढ़ना

उतर जाओ

नीचे जाओ

घटित होना

गिरना

में बदल जाते हैं

छिपाने

हरा देना

रोकना

देने के लिए

जंगली भागो

की घोषणा

धोना

बाहर जाओ

चलना

बैठने के लिए

घसीटना

गिरना

होना है

जैसा होना चाहिए

बैठ जाना

होना है

बैठने के लिए

खड़ा होना

उठो

वापस आ जाओ

होना है

हरा देना

परिवर्तनशील

बाहर ले जाना

तरसना

लगाना

बाहर जाओ

जाने के लिए

मरने के लिए

होना है

घटित होना

होना है

poking

छोड़ने के लिए

एक साथ हो जाओ

निर्दिष्ट

फाड़ना

पकड़ना

पालन करना

गिरना

धारण करना

हाथापाई करना

उतर जाओ

बहना

होना है

रोपण करने के लिए

भेजना

बाहर जाओ

बैठ जाना

खींचना

ऊपर कूदो

बैठने के लिए

दूर हो जाओ

चाहने के लिए

मिलना

होगा

आने के लिए

मरने के लिए

बनने के लिए

जाने के लिए

मरने के लिए

बैठ जाना

के माध्यम से चलाएँ

दफनाने के लिए

छोड़ने के लिए

वापस आ जाओ

टूट जाना

अतिरिक्त व्याकरण की विशेषताएं

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

 TAuxDicArticle "" { key = {"tomita:address.cxx" type=CUSTOM} }

अब fact_types.proto में एक नया Street

तथ्य जोड़ें जिसे हम पुनः प्राप्त करना चाहते हैं। यह दो क्षेत्रों से मिलकर बनेगा: अनिवार्य (सड़क का नाम) और वैकल्पिक (विवरणक)।

 message Street: NFactType.TFact { required string StreetName = 1; optional string Descr = 2; }

व्याकरण लिखने के लिए सीधे जाने के लिए, आपको कई नई अवधारणाओं को पेश करने की आवश्यकता है जिन्हें हमने पहले नहीं छुआ है।

पहली अवधारणा ऑपरेटरों की है। वे आपको व्याकरण नियमों के अधिक सुविधाजनक संक्षिप्त अंकन प्राप्त करने की अनुमति देते हैं:

* - चरित्र 0 या अधिक बार दोहराया जाता है;
+ - चरित्र को 1 या अधिक बार दोहराया जाता है;
() - प्रतीक को नियम 0 या 1 समय में शामिल किया गया है;
| - ऑपरेटर "या"।

व्याकरण लिखने के लिए आगे बढ़ते हैं। हम address.cxx फ़ाइल में दो नियम लिखेंगे - पहले हम StreetW नॉनटर्मिनल का वर्णन करते हैं, जिसमें कुछ स्ट्रीट डिस्क्रिप्टर के नाम होंगे और दूसरे में, StreetSokr

- StreetSokr

संक्षिप्त रूप से।

 #encoding "utf8" StreetW -> '' | '' | '' | ''; StreetSokr -> '' | '' | '-' | '' | '';

अगला, हम नॉन-टर्मिनल StreetDescr

, जो दो पिछले वाले को जोड़ती है:

 StreetDescr -> StreetW | StreetSokr;

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

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

आकृति विज्ञान कूड़े gram

एक ऐसा क्षेत्र है जो शब्दकोष से किसी भी रूपात्मक श्रेणी से भरा जा सकता है: भाषण का हिस्सा, लिंग, संख्या, मामला, समय, मूड, आवाज, व्यक्ति, आदि। <gram = “, , ”>

;
व्याकरणिक लेबल - लेबल का एक समूह जो निकाले गए श्रृंखला के रजिस्टर पर प्रतिबंध लगाता है: <h-reg1>, <l-reg>

;

विशेष अंक - एक वाक्य में एक शब्द की स्थिति, वर्णमाला, आदि को प्रतिबिंबित कर सकते हैं।: ,,

, , ; 
      

        
        
        
      

         :   ,      : <~fw>, <~lat> .

, , ; 
      

        
        
        
      

         :   ,      : <~fw>, <~lat>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     .

थोड़ा अलग सिंटैक्टिक कूड़े है . ( ), . .

. ( ), . .

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

जीनस, संख्या और मामले द्वारा: gnc-agr

;
लिंग और संख्या के अनुसार: gn-agr

;
केस: c-agr

।

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

 S -> A<gnc-agr[1], nc-agr[2]> B<gnc-agr[1]> C<nc-agr[2]>;

सड़क नामों के लिए हमारे नियम पर वापस जाएं। आमतौर पर सड़क का नाम या तो विवरणक (Moskovsky Prospekt) के साथ एक विशेषण सहमत है, या नाममात्र या जनन मामले में एक संज्ञा समूह (कुजनेत्स्की सबसे स्ट्रीट या क्रास्नाय कुर्स्कोव स्ट्रीट) के साथ खड़ा है। सबसे पहले, संज्ञा वाक्यांश का वर्णन करें। इस श्रृंखला का मुख्य तत्व एक शब्द होगा जिसे इसके (वैष्णिह वोडी स्ट्रीट) विशेषण से पहले स्वीकार किया जा सकता है, और उसके बाद - आनुवंशिक मामले (मास्को की आठवीं शताब्दी) में एक और शब्द।

 StreetNameNoun -> (Adj<gnc-agr[1]>) Word<gnc-agr[1],rt> (Word<gram="">);

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

 StreetNameAdj -> Adj<h-reg1> Adj*;

मूल नियमों में, हम एक साथ वर्णनकर्ता और सड़क के नाम एकत्र करेंगे और व्याख्या जोड़ेंगे। हम मानते हैं कि नाम समूह द्वारा व्यक्त की गई सड़क का नाम सड़क विवरणक के बाद आता है। इसे पूंजीकृत किया जाना चाहिए और नाममात्र या StreetNameNoun

मामले में खड़ा होना चाहिए (गैर-टर्मिनल StreetNameNoun

को सौंपे गए StreetNameNoun

श्रृंखला के मुख्य शब्द पर लागू होंगे)। स्ट्रीट डिस्क्रिप्टर की व्याख्या Descr

तथ्य के StreetName

क्षेत्र में और StreetName

स्ट्रीट नाम में की StreetName

।

 Street -> StreetDescr interp (Street.Descr) StreetNameNoun<gram="", h-reg1> interp (Street.StreetName); Street -> StreetDescr interp (Street.Descr) StreetNameNoun<gram="", h-reg1> interp (Street.StreetName);

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

, wfl

— , wfm

— .

 S -> A<wff=/[0-9]+.?/>;

, , 0 99, , . , — — NumberW

.

 NumberW_1 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/>; NumberW_2 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/>; NumberW_3 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/>; NumberW -> NumberW_1 | NumberW_2 | NumberW_3;

, -, . , , , .. , . . outgram

, . :

 NumberW_1 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/> {outgram=",,"}; NumberW_2 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/> {outgram=",,"}; NumberW_3 -> AnyWord<wff=/[1-9]?[0-9]-?(()|()|()|)/> {outgram=",,"};

StreetNameAdj

: NumberW

, , .

 StreetNameAdj -> NumberW<gnc-agr[1]> Adj<gnc-agr[1]>;

, StreetNameAdj

. , , , . ̈ , .. .

 Street -> StreetNameAdj<gnc-agr[1]> interp (Street.StreetName) StreetW<gnc-agr[1]> interp (Street.Descr); Street -> StreetNameAdj interp (Street.StreetName) StreetSokr interp (Street.Descr); Street -> StreetW<gnc-agr[1]> interp (Street.Descr) StreetNameAdj<gnc-agr[1]> interp (Street.StreetName); Street -> StreetSokr interp (Street.Descr) StreetNameAdj interp (Street.StreetName);

. , ( ). , , , , . , . not_norm

. , , .

 Street -> StreetDescr interp (Street.Descr) StreetNameNoun<gram="", h-reg1> interp (Street.StreetName::not_norm); Street -> StreetDescr interp (Street.Descr) StreetNameNoun<gram="", h-reg1> interp (Street.StreetName::not_norm);

, , address.cxx Street

. , , Input

input1.txt

 Input = {File = "input1.txt"} Output = {File = "output.txt" Format = text} Articles = [ { Name = "" } ] Facts = [ { Name = "Street" } ]

, :

परिणाम

StreetName	descr
पता
1 डबरोवस्काया	str
लोअर मस्लोवका	str
दुनिया का	एवेन्यू
1 व्लादिमीरकाया	सड़क
बोलश्या सेमेनोवस्काया	str
Komsomol	एवेन्यू
तैमूर फ्रुंज़े	str

. dic.gzt, — , , , .. . . .

. , ̈ . — — :

 TAuxDicArticle "" { key = "" | "" | ""}

, :

 TAuxDicArticle "" { key = {"tomita:address.cxx" type=CUSTOM}}

̈ . , , ̈ — . , , , , , ..

 TAuxDicArticle "" { key = {   mainword=2 agr=gnc_agr} }

«» — « », , , . , .

, :

 TAuxDicArticle "-" { key = "-" key = "" key = "" lemma = "-" }

, , . kwtype

. , , (), , .. , kwtype

. kwset

, . :

 Animals -> Word <kwtype="">; Forest -> Word <kwset=["", ""]>;

, ̈ . TAuxDicArticle, , , , . kwtypes.proto. , :

 import "base.proto"; import "articles_base.proto"; import "kwtypes_base.proto";

̈ . . message

, , . .

 message surname : TAuxDicArticle {}

. .gzt- surnames.gzt, , ̈ surname. , kwtypes.proto, , . , , TAuxDicArticle

surname

:

 encoding "utf8"; import "kwtypes.proto"; surname "" { key = "" } surname "" { key = "" } surname "" { key = "" }

, import "surnames.gzt";

। import "kwtypes.proto";

।

, , , : « -». imeni.cxx. , . . , surname

. ̈ , . + “” ( ).

 #encoding "utf8" Initial -> Word<wff=/[-]\./>; Initials -> Initial Initial; FIO -> Initials Word<kwtype=surname>; Imeni ->''<gram=", "> FIO;

. :

 TAuxDicArticle "" { key = {"tomita:imeni.cxx" type=CUSTOM} }

config.proto ( ) , — . , imeni.cxx input2.txt . . , pretty.html , .

, , . : kwtype

, ̈ , , #include

. #include

— , , . kwtype

. imeni.cxx ̈ , . org.cxx. .

 #encoding "utf8" OrgDescr -> '' | '' | '';

« -». kwtype

, «», imeni.cxx. , , kwtype

— . — .

, .

 Org_ -> OrgDescr Word<kwtype="">; Org -> Org_ interp (Org.Name);

 TAuxDicArticle "" { key = {"tomita:org.cxx" type=CUSTOM} }

fact_types.proto:

 message Org: NFactType.TFact { required string Name = 1; }

, , ̈ . , “”. , “Org”.

 Articles = [ { Name = "" } ] Facts = [ { Name = "Org" } ]

pretty.html. « . . ».

? « .. » imeni.cxx. « _..», .. , org.cxx.

, , (.. kwtype

): , .

. , -, .

अपनी परियोजनाओं में टॉमिता-पार्सर का उपयोग कैसे करें। प्रैक्टिकल कोर्स

अतिरिक्त व्याकरण की विशेषताएं

More articles: