मेरे पास टेक्स्ट डॉक्यूमेंट हैं जिनमें मुख्य रूप से आइटम की सूची है।
प्रत्येक आइटम विभिन्न प्रकारों से कई टोकन का एक समूह है: FirstName, LastName, BirthDate, PhoneNumber, City, Occupation, आदि। टोकन एक शब्दों का समूह है।
आइटम कई लाइनों पर झूठ बोल सकते हैं।
दस्तावेज़ के आइटम में समान सिंटैक्स होता है, लेकिन जरूरी नहीं कि वे बिल्कुल समान हों।
वे आइटम के बीच कुछ और / कम टोकन हो सकते हैं, साथ ही आइटम के भीतर भी।
FirstName LastName BirthDate PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber
Occupation UnrecognizedToken
FirstName LastName PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber
City Occupation
लक्ष्य के लिए इस्तेमाल व्याकरण की पहचान है, जैसे
Occupation City
और अंत में सभी मदों की पहचान करें, यहां तक कि सोचा कि वे बिल्कुल मेल नहीं खाते हैं।
छोटे और पठनीय रहने के लिए, आइए उन कुछ प्रकारों को नामित करने के लिए कुछ उपनाम A, B, C, D, ... का उपयोग करें।
जैसे
A B C
D F
A B C
D E F
F
A B C
D E E F
A C B
D E F
A B D C
D E F
A B C
D E F G
यहां हम देख सकते हैं कि आइटम सिंटैक्स है
A B C
D E F
क्योंकि यह वही है जो सबसे अच्छे अनुक्रम से मेल खाता है।
वाक्यविन्यास (टोकन प्रकार और आदेश) एक दस्तावेज़ से दूसरे में बहुत भिन्न हो सकते हैं। उदाहरण के लिए किसी अन्य दस्तावेज़ में वह सूची हो सकती है
D A
D A
D
D A
B
D A
लक्ष्य यह है कि इसके बारे में पूर्व ज्ञान के बिना सिंटैक्स का पता लगाना ।
अब से, एक नई रेखा को एक टोकन के रूप में भी माना जाता है। दस्तावेज़ को टोकन के 1-आयाम अनुक्रम के रूप में दर्शाया जा सकता है:
यहाँ दोहराया क्रम होगा A B C Bक्योंकि यह एक टोकन है जो कम से कम संघर्ष पैदा करता है।
इसे थोड़ा जटिल करते हैं। अब से प्रत्येक टोकन का कोई निर्धारित प्रकार नहीं है। वास्तविक दुनिया में, हम हमेशा कुछ प्रकार के टोकन के 100% सुनिश्चित नहीं होते हैं। इसके बजाय, हम इसे एक निश्चित प्रकार होने की संभावना देते हैं।
A 0.2 A 0.0 A 0.1
B 0.5 B 0.5 B 0.9 etc.
C 0.0 C 0.0 C 0.0
D 0.3 D 0.5 D 0.0
यहाँ एक अमूर्त ग्राफिक है जिसे मैं प्राप्त करना चाहता हूँ:
समाधान ए माना जाता है: टोकन के एक पैच का रूपांतरण
इस समाधान में टोकन के कई पैच के साथ एक कनवल्शन लागू करना शामिल है, और कम से कम संघर्ष पैदा करने वाले को लेना है।
यहां का कठिन हिस्सा अवलोकन अनुक्रम के साथ रोल करने के लिए संभावित पैच ढूंढना है। इस एक के लिए कुछ विचार, लेकिन बहुत संतोषजनक कुछ भी नहीं:
टोकन के बीच संक्रमण का एक मार्कोव मॉडल बनाएंदोष: चूंकि मार्कोव मॉडल में कोई मेमोरी नहीं है, इसलिए हम संक्रमण के आदेशों को खो देंगे। उदाहरण यदि दोहराया क्रम है A B C B D, तो हम इस तथ्य को खो देते हैं कि A-> B C-> B से पहले होता है।
यह डीएनए / आरएनए में न्यूक्लियोबेस (जीटीएसी) का विश्लेषण करने के लिए जीव विज्ञान में बड़े पैमाने पर उपयोग किया जाता है। दोष: प्रत्यय के पेड़ सटीक टोकन (जैसे वर्ण) के सटीक मिलान के लिए अच्छे हैं। हमारे पास न तो सटीक क्रम हैं, न ही सटीक टोकन।
पाशविक बलहर आकार के हर संयोजन का प्रयास करें। वास्तव में काम कर सकता था, लेकिन इसमें कुछ (लंबा (लंबा)) समय लगेगा।
बी माना जाने वाला समाधान: प्रत्ययों की लेवेंसहाइट दूरी की एक तालिका बनाएँ
अंतर्ज्ञान यह है कि हर प्रत्यय से हर प्रत्यय की दूरी की गणना करते समय दूरी के कुछ स्थानीय मिनीमा मौजूद हो सकते हैं।
डिस्टेंस फंक्शन लेवेंसाइटिन दूरी है, लेकिन हम प्रत्येक टोकन के लिए एक निश्चित प्रकार होने के बजाय, एक निश्चित प्रकार के होने की संभावना को ध्यान में रखते हुए भविष्य में इसे अनुकूलित करने में सक्षम होंगे।
उस प्रदर्शन में सरल रहने के लिए, हम निश्चित-प्रकार के टोकन का उपयोग करेंगे, और टोकन के बीच की दूरी की गणना करने के लिए क्लासिक लेवेंशटेइन का उपयोग करेंगे।
जैसे चलो इनपुट अनुक्रम है ABCGDEFGH ABCDEFGH ABCDNEFGH।
हम हर प्रत्यय के साथ हर प्रत्यय की दूरी की गणना करते हैं (समान आकार का होना):
for i = 0 to sequence.lengh
for j = i to sequence.lengh
# Create the suffixes
suffixA = sequence.substr(i)
suffixB = sequence.substr(j)
# Make the suffixes the same size
chunkLen = Math.min(suffixA.length, suffixB.length)
suffixA = suffixA.substr(0, chunkLen)
suffixB = suffixB.substr(0, chunkLen)
# Compute the distance
distance[i][j] = LevenshteinDistance(suffixA, suffixB)
हमें निम्न परिणाम मिलते हैं (सफेद छोटी दूरी, काला बड़ा है):
अब, यह स्पष्ट है कि स्वयं की तुलना में किसी भी प्रत्यय की अशक्त दूरी होगी। लेकिन हम प्रत्यय (बिल्कुल या आंशिक रूप से) से मेल खाते हुए दिलचस्पी नहीं रखते हैं, इसलिए हम उस हिस्से को काटते हैं।
चूंकि प्रत्यय समान आकार के होते हैं, इसलिए लंबी स्ट्रिंग की तुलना में हमेशा छोटे तारों की तुलना में एक बड़ी दूरी होगी।
हमें यह क्षतिपूर्ति करने की आवश्यकता है कि दायें (+ P) से शुरू होने वाले चिकने दंड से, रैखिक रूप से बाईं ओर लुप्त होती।
मुझे यकीन नहीं है कि एक अच्छा जुर्माना समारोह कैसे चुनना है जो सभी मामलों में फिट होगा।
यहां हम चरम दाएं पर (+ पी = 6) जुर्माना लगाते हैं, 0 से बाईं ओर लुप्त होती है।
अब हम स्पष्ट रूप से 2 स्पष्ट विकर्ण रेखाओं को देख सकते हैं। उस क्रम में 3 आइटम (Item1, Item2, Item3) हैं। सबसे लंबी पंक्ति Item1 बनाम Item2 और Item2 बनाम Item3 के बीच मेल का प्रतिनिधित्व करती है। दूसरा सबसे लंबा आइटम 1 बनाम आइटम 3 के बीच मिलान का प्रतिनिधित्व करता है।
अब मुझे उस डेटा का फायदा उठाने के सबसे अच्छे तरीके पर यकीन नहीं है। क्या यह उच्चतम विकर्ण रेखाओं को लेने के समान सरल है?
चलिए मान लेते हैं।
आइए प्रत्येक तिरछे से शुरू होने वाली विकर्ण रेखा के औसत मूल्य की गणना करें। हम निम्न चित्र (मैट्रिक्स के नीचे वेक्टर) पर परिणाम देख सकते हैं:
स्पष्ट रूप से 3 स्थानीय मिनीमा हैं, जो प्रत्येक आइटम की शुरुआत से मेल खाते हैं। शानदार लग रहा है!
अब अनुक्रम में कुछ और खामियों को जोड़ते हैं:
ABCGDEFGH ABCDEFGH TROLL ABCDEFGH
स्पष्ट रूप से अब, विकर्ण औसत के हमारे वेक्टर को गड़बड़ कर दिया गया है, और हम अब इसका फायदा नहीं उठा सकते ...
मेरी धारणा यह है कि यह एक स्वनिर्धारित दूरी समारोह (लेवेंसहेटिन के बजाय) द्वारा हल किया जा सकता है, जहां एक पूरे ब्लॉक का सम्मिलन इतना दंडित नहीं हो सकता है। यही मैं निश्चित नहीं हूं।
निष्कर्ष
हमारी समस्या के समाधान के लिए कोई भी खोजपूर्ण समाधान आधारित समाधान नहीं लगता है।
लेवेंसहाइट-दूरी-आधारित समाधान आशाजनक लगता है, खासकर क्योंकि यह संभावना-आधारित-प्रकार के टोकन के साथ संगत है। लेकिन मुझे इसके बारे में अभी तक यकीन नहीं है कि इसके परिणामों का कैसे फायदा उठाया जाए।
यदि आप संबंधित क्षेत्र में अनुभव रखते हैं, और हमें देने के लिए कुछ अच्छे संकेत, या अन्य तकनीकों का पता लगाने के लिए मैं बहुत आभारी हूं। पहले से ही बहुत - बहुत धन्यवाद।