टोकननाइजेशन, और ल्यूसीन के साथ अनुक्रमण, बाहरी टोकननाइजेशन और भाषण के हिस्से को कैसे संभालना है?

Question

मैं अपना खुद का निर्माण करना चाहता हूं - यहां यह सुनिश्चित नहीं है कि कौन सा - टोकनेज़र (ल्यूसीन दृष्टिकोण से) या मेरे अपने विश्लेषक। मैं पहले से ही एक कोड है कि (शब्द में मेरे दस्तावेज़ tokenize एक सूची < स्ट्रिंग> या एक सूची < वर्ड> जहां वर्ड 3 सार्वजनिक स्ट्रिंग के साथ कंटेनर का केवल एक प्रकार के साथ एक वर्ग है के रूप में लिखें: शब्द, स्थिति, लेम्मा - भाग-भाषण टैग के लिए pos स्टैंड)।

मुझे यकीन है कि मैं क्या सूचकांक करने जा रहा हूँ, हो सकता है केवल "Word.lemma" या की तरह "Word.lemma + '#' + Word.pos" कुछ नहीं कर रहा हूँ, शायद मैं कुछ छानने करना होगा भाषण के आधार पर एक स्टॉप शब्द सूची से।

btw यहाँ मेरी गलतफहमी है: मुझे यकीन है कि मैं कहाँ Lucene एपीआई के प्लग चाहिए नहीं कर रहा हूँ,

मैं एक नया tokenizer अंदर अपने ही tokenizer लपेट करना चाहिए? क्या मुझे टोकनस्ट्रीम को फिर से लिखना चाहिए? क्या मुझे लगता है कि यह टोकननाइज़र के बजाय विश्लेषक का काम है? या shoud मैं सब कुछ बाईपास और सीधे इंडेक्सवाइटर, फील्डबल और इतने पर, इंडेक्स के अंदर अपना शब्द जोड़कर सीधे मेरी अनुक्रमणिका का निर्माण?

सादर (यदि ऐसा है तो आप यह कैसे बनाने के लिए पर किसी भी दस्तावेज की जानते हो खरोंच से खुद सूचकांक जब बाईपास ing विश्लेषण प्रक्रिया है)

संपादित: सबसे आसान तरीका org.apache होना चाहिए हो सकता है .commons.lang.StringUtils.join मेरे शब्द -s मेरे व्यक्तिगत टोकनेज़र/विश्लेषक के बाहर निकलने पर एक स्थान के साथ और लुसीन (और अन्य शास्त्रीय फ़िल्टर) को खिलाने के लिए व्हाइटस्पेस टोकनाइज़र पर भरोसा करते हैं?

संपादित: हां, मैं EnglishLemmaTokenizer पढ़ा है Larsmans द्वारा बताया ... लेकिन जहां मैं अभी भी उलझन में हूँ, वास्तव में मैं एक पूरा * सूची < वर्ड के साथ अपने स्वयं के विश्लेषण/tokenization प्रक्रिया समाप्त करता है > * (शब्द वर्ग रैपिंग .form/.pos/.lemma), यह प्रक्रिया जावा में लिपटे बाहरी बाइनरी पर भरोसा करती है (यह एक अनिवार्य है/अन्यथा नहीं कर सकता - यह एक पर नहीं है उपभोक्ता दृष्टिकोण, मुझे परिणामस्वरूप पूर्ण सूची मिलती है) और मैं अभी भी नहीं देखता कि मुझे सामान्य ल्यूसीन विश्लेषण प्रक्रिया पर वापस जाने के लिए इसे फिर से कैसे लपेटना चाहिए।

मैं भी टीएफ.आईडीएफ के साथ टर्म वेक्टर सुविधा का उपयोग कर रहा हूं जैसे स्कोरिंग (स्वयं को फिर से परिभाषित किया जा सकता है), मुझे निकटता खोज में दिलचस्पी हो सकती है, इस प्रकार, कुछ शब्दों को उनके भाग-भाषण से पहले प्रदान करने से पहले उन्हें ल्यूसीन में निर्मित टोकननाइज़र या आंतरिक विश्लेषक के लिए एक बुरा विचार प्रतीत हो सकता है। और मुझे ल्यूसीन तरीके से Word.form/Word.pos/Word.lemma (या यहां तक ​​कि अन्य Word.anyOtherUnterestingAttribute) को लपेटने के "उचित" तरीके के बारे में सोचने में कठिनाइयां हैं।

संपादित करें: Btw, यहाँ कोड का एक टुकड़ा है कि मैं @Larsmans में से एक से प्रेरित लिखने है:

class MyLuceneTokenizer extends TokenStream { 

    private PositionIncrementAttribute posIncrement; 
    private CharTermAttribute termAttribute; 

    private List<TaggedWord> tagged; 
    private int position; 

    public MyLuceneTokenizer(Reader input, String language, String pathToExternalBinary) { 
     super(); 

     posIncrement = addAttribute(PositionIncrementAttribute.class); 
     termAttribute = addAttribute(CharTermAttribute.class); // TermAttribute is deprecated! 

     // import com.google.common.io.CharStreams;    
     text = CharStreams.toString(input); //see http://stackoverflow.com/questions/309424/in-java-how-do-i-read-convert-an-inputstream-to-a-string 
     tagged = MyTaggerWrapper.doTagging(text, language, pathToExternalBinary); 
     position = 0; 
    } 

    public final boolean incrementToken() 
      throws IOException { 
     if (position > tagged.size() -1) { 
      return false; 
     } 

     int increment = 1; // will probably be changed later depending upon any POS filtering or insertion @ same place... 
     String form = (tagged.get(position)).word; 
     String pos = (tagged.get(position)).pos; 
     String lemma = (tagged.get(position)).lemma; 

     // logic filtering should be here... 
     // BTW we have broken the idea behing the Lucene nested filters or analyzers! 
     String kept = lemma; 

     if (kept != null) { 
      posIncrement.setPositionIncrement(increment); 
      char[] asCharArray = kept.toCharArray(); 
      termAttribute.copyBuffer(asCharArray, 0, asCharArray.length); 
      //termAttribute.setTermBuffer(kept); 
      position++; 
     } 

     return true; 
    } 
} 

class MyLuceneAnalyzer extends Analyzer { 
    private String language; 
    private String pathToExternalBinary; 

    public MyLuceneAnalyzer(String language, String pathToExternalBinary) { 
     this.language = language; 
     this.pathToExternalBinary = pathToExternalBinary; 
    } 

    @Override 
    public TokenStream tokenStream(String fieldname, Reader input) { 
     return new MyLuceneTokenizer(input, language, pathToExternalBinary); 
    } 
} 

Answer 1

वहाँ विभिन्न विकल्प यहाँ हैं, लेकिन जब मैं एक पीओएस टैगर लपेटो करने की कोशिश की लुसीन में, मैंने पाया कि एक नया TokenStream लागू करना और एक नए Analyzer के अंदर लपेटना सबसे आसान विकल्प था। किसी भी मामले में, IndexWriter के साथ मिलकर सीधे एक बुरा विचार लगता है। आप मेरा कोड on my GitHub पा सकते हैं।

Answer 2

यदि आप यूआईएमए का उपयोग करना चाहते हैं, तो सैल्मन रन में example है। लेकिन यूआईएमए वर्कफ़्लो को शामिल करने के लिए लुसीन कॉन्ट्रिब मॉड्यूल के भीतर एक प्रयास है, here और here देखें।