सूचकांक वाक्य के लिए सर्वश्रेष्ठ एल्गोरिदम

Question

कल्पना कीजिए कि मेरे पास ऐसी स्थिति है जहां मुझे वाक्यों को अनुक्रमित करने की आवश्यकता है। मुझे इसे थोड़ा गहरा समझाएं।

1. सुंदर आकाश:

   उदाहरण के लिए मैं इन वाक्यों की है।

2. सुंदर आकाश सपना।
3. सुंदर सपना।

जहां तक ​​मेरा कल्पना कर सकते हैं सूचकांक कुछ इस तरह दिखना चाहिए:

alt text http://img7.imageshack.us/img7/4029/indexarb.png

लेकिन यह भी मैं इन शब्दों में से किसी से खोज करना चाहते हैं।

उदाहरण के लिए, यदि मैं "द" द्वारा खोज करता हूं तो इसे मुझे "सुंदर" से कनेक्शन देना चाहिए। यदि मैं "खूबसूरत" से खोज करता हूं तो मुझे मुझे (पिछला) "द", (अगला) "आकाश" और "सपना" से कनेक्शन देना चाहिए। अगर मैं "आकाश" से खोजता हूं तो इसे "सुंदर" और आदि से कनेक्शन (पिछला) कनेक्शन देना चाहिए ...

कोई विचार? शायद आप इस तरह की समस्या के लिए पहले से ही मौजूदा एल्गोरिदम जानते हैं?

Answer 1

यह आपको बंद करते हैं, सी # में मिलता है oughta:

class Program 
{ 
    public class Node 
    { 
     private string _term; 
     private Dictionary<string, KeyValuePair<Node, Node>> _related = new Dictionary<string, KeyValuePair<Node, Node>>(); 

     public Node(string term) 
     { 
      _term = term; 
     } 

     public void Add(string phrase, Node previous, string [] phraseRemainder, Dictionary<string,Node> existing) 
     { 
      Node next= null; 
      if (phraseRemainder.Length > 0) 
      { 
       if (!existing.TryGetValue(phraseRemainder[0], out next)) 
       { 
        existing[phraseRemainder[0]] = next = new Node(phraseRemainder[0]); 
       } 
       next.Add(phrase, this, phraseRemainder.Skip(1).ToArray(), existing); 
      } 
      _related.Add(phrase, new KeyValuePair<Node, Node>(previous, next)); 

     } 
    } 


    static void Main(string[] args) 
    { 
     string [] sentences = 
      new string [] { 
       "The beautiful sky", 
       "Beautiful sky dream", 
       "beautiful dream" 
      }; 

     Dictionary<string, Node> parsedSentences = new Dictionary<string,Node>(); 

     foreach(string sentence in sentences) 
     { 
      string [] words = sentence.ToLowerInvariant().Split(' '); 
      Node startNode; 
      if (!parsedSentences.TryGetValue(words[0],out startNode)) 
      { 
       parsedSentences[words[0]] = startNode = new Node(words[0]); 
      } 
      if (words.Length > 1) 
       startNode.Add(sentence,null,words.Skip(1).ToArray(),parsedSentences); 
     } 
    } 
} 

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

Answer 2

ट्री खोज एल्गोरिदम (BST की तरह, ect)

Answer 3

का उपयोग करते हुए एक associative array आप जल्दी से पर्ल में वाक्य पार्स करने के लिए अनुमति देगा। यह अपेक्षाकृत तेज़ है जितना आप अनुमान लगाएंगे और इसे उच्च स्तर की भाषा द्वारा बाद में उपयोग के लिए संरचना जैसे पेड़ में प्रभावी रूप से बाहर निकाला जा सकता है।

Answer 4

आप वाक्यों के शब्दों से बने Markov chains में कोशिश और खोद सकते हैं। इसके अलावा आपको दोनों तरफ श्रृंखला की आवश्यकता होगी (यानी अगले और पिछले शब्दों को ढूंढने के लिए), यानी संभावित संभावित शब्दों को स्टोर करें जो दिए गए या उसके ठीक पहले दिखाई दें।

बेशक, मार्कोव श्रृंखला सामग्री उत्पन्न करने के लिए एक स्टोकास्टिक प्रक्रिया है, हालांकि इसी तरह की जानकारी का उपयोग आपकी आवश्यक जानकारी को संग्रहीत करने के लिए किया जा सकता है।

Answer 5

ऐसा दिखता है जैसे निम्न तालिकाओं के साथ एक बहुत ही सरल डेटाबेस में संग्रहित किया जा सकता है:

Words: 
    Id  integer primary-key 
    Word varchar(20) 
Following: 
    WordId1 integer foreign-key Words(Id) indexed 
    WordId2 integer foreign-key Words(Id) indexed 

फिर, जब भी आप एक वाक्य को पार्स, केवल वे जो पहले से ही वहाँ नहीं कर रहे हैं डालें, इस प्रकार है:

The beautiful sky. 
    Words (1,'the') 
    Words (2, 'beautiful') 
    Words (3,, 'sky') 
    Following (1, 2) 
    Following (2, 3) 
Beautiful sky dream. 
    Words (4, 'dream') 
    Following (3, 4) 
Beautiful dream. 
    Following (2, 4) 

फिर आप अपने दिल की सामग्री से पूछ सकते हैं कि कौन से शब्द दूसरे शब्दों का पालन करते हैं या आगे जाते हैं।

Answer 6

लघु उत्तर

पिछले/आगे लिंक के दो वैक्टर के साथ एक struct बनाएँ। फिर शब्द के रूप में कुंजी के साथ एक हैश तालिका में structs शब्द संग्रहित करें।

लांग उत्तर

यह एक भाषाई पार्स समस्या यह है कि जब तक आप आसानी से निरर्थक शब्दों वाला कोई आपत्ति नहीं है हल नहीं किया जाता है।

1. मैं पार्क बास्केटबॉल कोर्ट में गया।
2. क्या आप कार पार्क करेंगे।
   1. मैं पार्क कार के पास गया:

   आपका जोड़ने एल्गोरिथ्म की तरह वाक्य पैदा करेगा।

3. क्या आप बास्केटबॉल कोर्ट पार्क करेंगे।

मुझे इस के एसईओ अनुप्रयोगों के बारे में बिल्कुल यकीन नहीं है, लेकिन मैं एक खोज परिणाम लेने वाली एक और अस्पष्ट स्पैम साइट का स्वागत नहीं करता।

Answer 7

मुझे लगता है कि आप किसी प्रकार की Inverted index संरचना चाहते हैं। आपके पास (sentence_id, position) फॉर्म के जोड़े की सूचियों को इंगित करने वाली कुंजी के रूप में शब्दों के साथ हैशमैप होगा। फिर आप अपने वाक्यों को सरणी या लिंक्ड सूचियों के रूप में स्टोर करेंगे। आपका उदाहरण इस प्रकार दिखाई देगा:

sentence[0] = ['the','beautiful', 'sky']; 
sentence[1] = ['beautiful','sky', 'dream']; 
sentence[2] = ['beautiful', 'dream']; 

inverted_index = 
{ 
'the': {(0,0)}, 
'beautiful': {(0,1), (1,0), (2,0)}, 
'sky' : {(0,2),(1,1)}, 
'dream':{(1,2), (2,1)} 
}; 

शब्द निरंतर समय में किया जा सकता पर इस संरचना लुकअप का उपयोग करना। जिस शब्द को आप चाहते हैं उसे पहचानने के बाद, दिए गए वाक्य में पिछले और बाद वाले शब्द को ढूंढना निरंतर समय में किया जा सकता है।

उम्मीद है कि इससे मदद मिलती है।