Neo4J

Question

ए Markov chain के साथ एक मार्कोव चेन को सिम्युलेट करना एक Markov chain राज्यों के एक समूह से बना है जो किसी निश्चित संभावना के साथ अन्य राज्यों में संक्रमण कर सकता है।

प्रत्येक राज्य के लिए नोड बनाने, प्रत्येक संक्रमण के लिए एक रिश्ता बनाकर, और फिर उचित संभावना के साथ संक्रमण संबंधों को एनोटेट करके एक मार्कोव चेन को आसानी से नियो 4 जे में प्रदर्शित किया जा सकता है।

लेकिन, क्या आप अनुकरण कर सकते हैं Marko श्रृंखला Neo4J का उपयोग कर? उदाहरण के लिए, क्या नियो 4 जे को किसी निश्चित स्थिति में शुरू करने के लिए मजबूर किया जा सकता है और फिर अगले राज्य और अगले राज्य में संक्रमणों के आधार पर संक्रमण कर सकते हैं? क्या Neo4J इस राज्य की जगह के माध्यम से पथ के प्रिंटआउट के साथ वापस आ सकता है?

शायद यह एक साधारण उदाहरण के साथ समझना आसान है। मान लीजिए कि मैं my company's tech blog के पाठ के आधार पर अंग्रेजी का 2-ग्राम मॉडल बनाना चाहता हूं। मैं एक स्क्रिप्ट स्पिन करता हूं जो निम्न करता है:

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

अब जब नियो 4 जे ग्राफ पूरा हो गया है, तो मैं इसे अंग्रेजी के 2-ग्राम मॉडल से "वाक्य" कैसे बना सकता हूं? यहां आउटपुट जैसा दिख सकता है:

कोई जानकारी नहीं है LAT WHEY CRATICT FROURE BIRS GRPID REPTAGIN के डिमांडस्टोर का पदनाम सीआर का पुनर्गठन है।

Answer 1

नियो 4j उस कार्यक्षमता को प्रदान नहीं करता है जिसे आप बॉक्स से बाहर पूछ रहे हैं, लेकिन चूंकि आप पहले से ही अपने डेटाबेस को सही तरीके से पॉप्युलेट कर रहे हैं, इसलिए आपको जिस ट्रैवर्सल की आवश्यकता है वह कोड की कुछ पंक्तियां हैं।

मैंने कुछ प्रयोगों के साथ आपके प्रयोग here को फिर से बनाया है। सबसे पहले, मैं टेक्स्ट (चरण 2 और 3) के माध्यम से एक ही पास के साथ डेटाबेस को पॉप्युलेट करता हूं, लेकिन यह मामूली है। सबसे महत्वपूर्ण बात यह है कि, मैं केवल प्रत्येक रिश्ते पर घटनाओं की संख्या और नोड (चरण 4) पर कुल संख्या को संग्रहित करता हूं, क्योंकि मुझे नहीं लगता कि संभावनाओं की पूर्व-गणना करने की आवश्यकता है।

कोड है कि आप के लिए पूछ रहे हैं तो इस तरह दिखता है:

/** 
* A component that creates a random sentence by a random walk on a Markov Chain stored in Neo4j, produced by 
* {@link NGramDatabasePopulator}. 
*/ 
public class RandomSentenceCreator { 

    private final Random random = new Random(System.currentTimeMillis()); 

    /** 
    * Create a random sentence from the underlying n-gram model. Starts at a random node an follows random outgoing 
    * relationships of type {@link Constants#REL} with a probability proportional to that transition occurrence in the 
    * text that was processed to form the model. This happens until the desired length is achieved. In case a node with 
    * no outgoing relationships it reached, the walk is re-started from a random node. 
    * 
    * @param database storing the n-gram model. 
    * @param length desired number of characters in the random sentence. 
    * @return random sentence. 
    */ 
    public String createRandomSentence(GraphDatabaseService database, int length) { 
     Node startNode = randomNode(database); 
     return walk(startNode, length, 0); 
    } 

    private String walk(Node startNode, int maxLength, int currentLength) { 
     if (currentLength >= maxLength) { 
      return (String) startNode.getProperty(NAME); 
     } 

     int totalRelationships = (int) startNode.getProperty(TOTAL, 0); 
     if (totalRelationships == 0) { 
      //terminal node, restart from random 
      return walk(randomNode(startNode.getGraphDatabase()), maxLength, currentLength); 
     } 

     int choice = random.nextInt(totalRelationships) + 1; 
     int total = 0; 
     Iterator<Relationship> relationshipIterator = startNode.getRelationships(OUTGOING, REL).iterator(); 

     Relationship toFollow = null; 
     while (total < choice && relationshipIterator.hasNext()) { 
      toFollow = relationshipIterator.next(); 
      total += (int) toFollow.getProperty(PROBABILITY); 
     } 

     Node nextNode; 
     if (toFollow == null) { 
      //no relationship to follow => stay on the same node and try again 
      nextNode = startNode; 
     } else { 
      nextNode = toFollow.getEndNode(); 
     } 

     return ((String) nextNode.getProperty(NAME)).substring(0, 1) + walk(nextNode, maxLength, currentLength + 1); 
    } 

    private Node randomNode(GraphDatabaseService database) { 
     return random(GlobalGraphOperations.at(database).getAllNodes()); 
    } 
}