Comment obtenir un Token à partir d'un TokenStream Lucene ?

Question

J'essaie d'utiliser Apache Lucene pour la tokénisation, et je suis dérouté par le processus permettant d'obtenir des tokens à partir d'un fichier TokenStream .

Le pire, c'est que je regarde les commentaires dans les JavaDocs qui répondent à ma question.

http://lucene.apache.org/java/3_0_1/api/core/org/apache/lucene/analysis/TokenStream.html#incrementToken%28%29

D'une manière ou d'une autre, une AttributeSource est censé être utilisé, plutôt que Token s. Je suis totalement perdue.

Quelqu'un peut-il expliquer comment obtenir des informations de type jeton à partir d'un TokenStream ?

Answer 1

Oui, c'est un peu compliqué (comparé à la bonne vieille méthode), mais ça devrait le faire :

TokenStream tokenStream = analyzer.tokenStream(fieldName, reader);
OffsetAttribute offsetAttribute = tokenStream.getAttribute(OffsetAttribute.class);
TermAttribute termAttribute = tokenStream.getAttribute(TermAttribute.class);

while (tokenStream.incrementToken()) {
    int startOffset = offsetAttribute.startOffset();
    int endOffset = offsetAttribute.endOffset();
    String term = termAttribute.term();
}

Edit : Le nouveau chemin

Selon Donotello, TermAttribute a été déprécié au profit de CharTermAttribute . Selon jpountz (et la documentation de Lucene), addAttribute est plus souhaitable que getAttribute .

TokenStream tokenStream = analyzer.tokenStream(fieldName, reader);
OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);

tokenStream.reset();
while (tokenStream.incrementToken()) {
    int startOffset = offsetAttribute.startOffset();
    int endOffset = offsetAttribute.endOffset();
    String term = charTermAttribute.toString();
}

Answer 2

C'est comme ça que ça devrait être (une version propre de la réponse d'Adam) :

TokenStream stream = analyzer.tokenStream(null, new StringReader(text));
CharTermAttribute cattr = stream.addAttribute(CharTermAttribute.class);
stream.reset();
while (stream.incrementToken()) {
  System.out.println(cattr.toString());
}
stream.end();
stream.close();

Answer 3

Pour la dernière version de lucene 7.3.1

    // Test the tokenizer
    Analyzer testAnalyzer = new CJKAnalyzer();
    String testText = "Test Tokenizer";
    TokenStream ts = testAnalyzer.tokenStream("context", new StringReader(testText));
    OffsetAttribute offsetAtt = ts.addAttribute(OffsetAttribute.class);
    try {
        ts.reset(); // Resets this stream to the beginning. (Required)
        while (ts.incrementToken()) {
            // Use AttributeSource.reflectAsString(boolean)
            // for token stream debugging.
            System.out.println("token: " + ts.reflectAsString(true));

            System.out.println("token start offset: " + offsetAtt.startOffset());
            System.out.println("  token end offset: " + offsetAtt.endOffset());
        }
        ts.end();   // Perform end-of-stream operations, e.g. set the final offset.
    } finally {
        ts.close(); // Release resources associated with this stream.
    }

Référence : https://lucene.apache.org/core/7_3_1/core/org/apache/lucene/analysis/package-summary.html

Answer 4

Il y a deux variantes dans la question du PO :

1. Qu'est-ce que "le processus d'obtention de jetons à partir d'un TokenStream" ?
2. "Quelqu'un peut-il expliquer comment obtenir des informations de type jeton à partir d'un TokenStream ?"

Les versions récentes de l Documentation de Lucene pour Token disent (c'est nous qui soulignons) :

REMARQUE : Depuis la version 2.9 ... il est pas nécessaire Il n'est plus nécessaire d'utiliser Token, avec la nouvelle API TokenStream, elle peut être utilisée comme classe de commodité qui implémente tous les attributs, ce qui est particulièrement utile pour passer facilement de l'ancienne à la nouvelle API TokenStream.

Et TokenStream dit son API :

... est passé d'un système basé sur des jetons à un système basé sur des attributs ... la meilleure façon de stocker les informations d'un jeton est d'utiliser des AttributeImpls.

Les autres réponses à cette question couvrent le point 2 ci-dessus : comment obtenir de type jeton des informations provenant d'un TokenStream de la "nouvelle" manière recommandée en utilisant des attributs. En lisant la documentation, les développeurs de Lucene suggèrent que ce changement a été effectué, en partie, pour réduire le nombre d'objets individuels créés à la fois.

Mais comme certaines personnes l'ont fait remarquer dans les commentaires de ces réponses, elles ne répondent pas directement à la question n° 1 : comment obtenir une Token si vous avez vraiment envie/besoin de ce type ?

Avec le même changement d'API qui rend TokenStream un AttributeSource , Token met désormais en œuvre Attribute et peut être utilisé avec TokenStream.addAttribute tout comme les autres réponses montrent pour CharTermAttribute et OffsetAttribute . Ils ont donc bien répondu à cette partie de la question initiale, mais ils ne l'ont pas montrée.

Il est important que, bien que cette approche vous permette d'accéder à Token pendant que vous bouclez, il ne s'agit toujours que d'un seul objet, quel que soit le nombre de jetons logiques dans le flux. Chaque appel à incrementToken() changera l'état de la Token renvoyé par addAttribute Donc si votre but est de construire une collection de différentes Token à utiliser en dehors de la boucle, vous devrez effectuer un travail supplémentaire pour créer un objet de type nouveau Token comme une copie (profonde ?).