Package org.apache.lucene.analysis.ja

Class JapaneseTokenizer

java.lang.Object

org.apache.lucene.util.AttributeSource

org.apache.lucene.analysis.TokenStream

org.apache.lucene.analysis.Tokenizer

org.apache.lucene.analysis.ja.JapaneseTokenizer

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public final class JapaneseTokenizer
extends Tokenizer

Tokenizer for Japanese that uses morphological analysis.

This tokenizer sets a number of additional attributes:

• BaseFormAttribute containing base form for inflected adjectives and verbs.
• PartOfSpeechAttribute containing part-of-speech.
• ReadingAttribute containing reading and pronunciation.
• InflectionAttribute containing additional part-of-speech information for inflected forms.

This tokenizer uses a rolling Viterbi search to find the least cost segmentation (path) of the incoming characters. For tokens that appear to be compound (> length 2 for all Kanji, or > length 7 for non-Kanji), we see if there is a 2nd best segmentation of that token after applying penalties to the long tokens. If so, and the Mode is JapaneseTokenizer.Mode.SEARCH, we output the alternate segmentation as well.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	JapaneseTokenizer.Lattice
static class	JapaneseTokenizer.Mode	Tokenization mode: this determines how the tokenizer handles compound and unknown words.
(package private) static class	JapaneseTokenizer.Position
static class	JapaneseTokenizer.Type	Token type reflecting the original source of this token
(package private) static class	JapaneseTokenizer.WrappedPositionArray

Nested classes/interfaces inherited from class org.apache.lucene.util.AttributeSource

AttributeSource.State

Field Summary

Fields

Modifier and Type	Field	Description
private FST.Arc<java.lang.Long>	arc
private BaseFormAttribute	basicFormAtt
private RollingCharBuffer	buffer
private CharacterDefinition	characterDefinition
private ConnectionCosts	costs
static JapaneseTokenizer.Mode	DEFAULT_MODE	Default tokenization mode.
private TokenInfoDictionary	dictionary
private java.util.EnumMap<JapaneseTokenizer.Type,Dictionary>	dictionaryMap
private boolean	discardPunctuation
private GraphvizFormatter	dotOut
private boolean	end
private boolean	extendedMode
private TokenInfoFST	fst
private FST.BytesReader	fstReader
private InflectionAttribute	inflectionAtt
private int	lastBackTracePos
private int	lastTokenPos
private JapaneseTokenizer.Lattice	lattice
private static int	MAX_BACKTRACE_GAP
private static int	MAX_UNKNOWN_WORD_LENGTH
private int	nBestCost
private OffsetAttribute	offsetAtt
private boolean	outputCompounds
private boolean	outputNBest
private java.util.List<Token>	pending
private int	pos
private PartOfSpeechAttribute	posAtt
private PositionIncrementAttribute	posIncAtt
private JapaneseTokenizer.WrappedPositionArray	positions
private PositionLengthAttribute	posLengthAtt
private ReadingAttribute	readingAtt
private static int	SEARCH_MODE_KANJI_LENGTH
private static int	SEARCH_MODE_KANJI_PENALTY
private static int	SEARCH_MODE_OTHER_LENGTH
private static int	SEARCH_MODE_OTHER_PENALTY
private boolean	searchMode
private CharTermAttribute	termAtt
private UnknownDictionary	unkDictionary
private UserDictionary	userDictionary
private TokenInfoFST	userFST
private FST.BytesReader	userFSTReader
private static boolean	VERBOSE
private IntsRef	wordIdRef

Fields inherited from class org.apache.lucene.analysis.Tokenizer

input

Fields inherited from class org.apache.lucene.analysis.TokenStream

DEFAULT_TOKEN_ATTRIBUTE_FACTORY

Constructor Summary

Constructors

Constructor	Description
JapaneseTokenizer(UserDictionary userDictionary, boolean discardPunctuation, boolean discardCompoundToken, JapaneseTokenizer.Mode mode)	Create a new JapaneseTokenizer.
JapaneseTokenizer(UserDictionary userDictionary, boolean discardPunctuation, JapaneseTokenizer.Mode mode)	Create a new JapaneseTokenizer.
JapaneseTokenizer(AttributeFactory factory, TokenInfoDictionary systemDictionary, UnknownDictionary unkDictionary, ConnectionCosts connectionCosts, UserDictionary userDictionary, boolean discardPunctuation, boolean discardCompoundToken, JapaneseTokenizer.Mode mode)	Create a new JapaneseTokenizer, supplying a custom system dictionary and unknown dictionary.
JapaneseTokenizer(AttributeFactory factory, UserDictionary userDictionary, boolean discardPunctuation, boolean discardCompoundToken, JapaneseTokenizer.Mode mode)	Create a new JapaneseTokenizer using the system and unknown dictionaries shipped with Lucene.
JapaneseTokenizer(AttributeFactory factory, UserDictionary userDictionary, boolean discardPunctuation, JapaneseTokenizer.Mode mode)	Create a new JapaneseTokenizer using the system and unknown dictionaries shipped with Lucene.

Method Summary

Modifier and Type	Method	Description
private void	add(Dictionary dict, JapaneseTokenizer.Position fromPosData, int endPos, int wordID, JapaneseTokenizer.Type type, boolean addPenalty)
private void	backtrace(JapaneseTokenizer.Position endPosData, int fromIDX)
private void	backtraceNBest(JapaneseTokenizer.Position endPosData, boolean useEOS)
int	calcNBestCost(java.lang.String examples)
void	close()	Releases resources associated with this stream.
private int	computePenalty(int pos, int length)
private int	computeSecondBestThreshold(int pos, int length)
void	end()	This method is called by the consumer after the last token has been consumed, after TokenStream.incrementToken() returned false (using the new TokenStream API).
private void	fixupPendingList()
(package private) Dictionary	getDict(JapaneseTokenizer.Type type)
boolean	incrementToken()	Consumers (i.e., IndexWriter) use this method to advance the stream to the next token.
private static boolean	isPunctuation(char ch)
private void	parse()
private int	probeDelta(java.lang.String inText, java.lang.String requiredToken)
private void	pruneAndRescore(int startPos, int endPos, int bestStartIDX)
private void	registerNode(int node, char[] fragment)
void	reset()	This method is called by a consumer before it begins consumption using TokenStream.incrementToken().
private void	resetState()
void	setGraphvizFormatter(GraphvizFormatter dotOut)	Expert: set this to produce graphviz (dot) output of the Viterbi lattice
void	setNBestCost(int value)

Methods inherited from class org.apache.lucene.analysis.Tokenizer

correctOffset, setReader

Methods inherited from class org.apache.lucene.util.AttributeSource

addAttribute, addAttributeImpl, captureState, clearAttributes, cloneAttributes, copyTo, endAttributes, equals, getAttribute, getAttributeClassesIterator, getAttributeFactory, getAttributeImplsIterator, hasAttribute, hasAttributes, hashCode, reflectAsString, reflectWith, removeAllAttributes, restoreState, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

DEFAULT_MODE

public static final JapaneseTokenizer.Mode DEFAULT_MODE

Default tokenization mode. Currently this is JapaneseTokenizer.Mode.SEARCH.

VERBOSE

private static final boolean VERBOSE

See Also:

Constant Field Values

SEARCH_MODE_KANJI_LENGTH

private static final int SEARCH_MODE_KANJI_LENGTH

See Also:

Constant Field Values

SEARCH_MODE_OTHER_LENGTH

private static final int SEARCH_MODE_OTHER_LENGTH

See Also:

Constant Field Values

SEARCH_MODE_KANJI_PENALTY

private static final int SEARCH_MODE_KANJI_PENALTY

See Also:

Constant Field Values

SEARCH_MODE_OTHER_PENALTY

private static final int SEARCH_MODE_OTHER_PENALTY

See Also:

Constant Field Values

MAX_UNKNOWN_WORD_LENGTH

private static final int MAX_UNKNOWN_WORD_LENGTH

See Also:

Constant Field Values

MAX_BACKTRACE_GAP

private static final int MAX_BACKTRACE_GAP

See Also:

Constant Field Values

dictionaryMap

private final java.util.EnumMap<JapaneseTokenizer.Type,Dictionary> dictionaryMap

fst

private final TokenInfoFST fst

dictionary

private final TokenInfoDictionary dictionary

unkDictionary

private final UnknownDictionary unkDictionary

costs

private final ConnectionCosts costs

userDictionary

private final UserDictionary userDictionary

characterDefinition

private final CharacterDefinition characterDefinition

arc

private final FST.Arc<java.lang.Long> arc

fstReader

private final FST.BytesReader fstReader

wordIdRef

private final IntsRef wordIdRef

userFSTReader

private final FST.BytesReader userFSTReader

userFST

private final TokenInfoFST userFST

buffer

private final RollingCharBuffer buffer

positions

private final JapaneseTokenizer.WrappedPositionArray positions

discardPunctuation

private final boolean discardPunctuation

searchMode

private final boolean searchMode

extendedMode

private final boolean extendedMode

outputCompounds

private final boolean outputCompounds

outputNBest

private boolean outputNBest

nBestCost

private int nBestCost

end

private boolean end

lastBackTracePos

private int lastBackTracePos

lastTokenPos

private int lastTokenPos

pos

private int pos

pending

private final java.util.List<Token> pending

termAtt

private final CharTermAttribute termAtt

offsetAtt

private final OffsetAttribute offsetAtt

posIncAtt

private final PositionIncrementAttribute posIncAtt

posLengthAtt

private final PositionLengthAttribute posLengthAtt

basicFormAtt

private final BaseFormAttribute basicFormAtt

posAtt

private final PartOfSpeechAttribute posAtt

readingAtt

private final ReadingAttribute readingAtt

inflectionAtt

private final InflectionAttribute inflectionAtt

dotOut

private GraphvizFormatter dotOut

lattice

private JapaneseTokenizer.Lattice lattice

Constructor Detail

JapaneseTokenizer

public JapaneseTokenizer(UserDictionary userDictionary,
                         boolean discardPunctuation,
                         JapaneseTokenizer.Mode mode)

Create a new JapaneseTokenizer.

Uses the default AttributeFactory.

Parameters:

userDictionary - Optional: if non-null, user dictionary.

discardPunctuation - true if punctuation tokens should be dropped from the output.

mode - tokenization mode.

JapaneseTokenizer

public JapaneseTokenizer(UserDictionary userDictionary,
                         boolean discardPunctuation,
                         boolean discardCompoundToken,
                         JapaneseTokenizer.Mode mode)

Create a new JapaneseTokenizer.

Uses the default AttributeFactory.

Parameters:

userDictionary - Optional: if non-null, user dictionary.

discardPunctuation - true if punctuation tokens should be dropped from the output.

discardCompoundToken - true if compound tokens should be dropped from the output when tokenization mode is not NORMAL.

mode - tokenization mode.

JapaneseTokenizer

public JapaneseTokenizer(AttributeFactory factory,
                         UserDictionary userDictionary,
                         boolean discardPunctuation,
                         JapaneseTokenizer.Mode mode)

Create a new JapaneseTokenizer using the system and unknown dictionaries shipped with Lucene.

Parameters:

factory - the AttributeFactory to use

userDictionary - Optional: if non-null, user dictionary.

discardPunctuation - true if punctuation tokens should be dropped from the output.

mode - tokenization mode.

JapaneseTokenizer

public JapaneseTokenizer(AttributeFactory factory,
                         UserDictionary userDictionary,
                         boolean discardPunctuation,
                         boolean discardCompoundToken,
                         JapaneseTokenizer.Mode mode)

Create a new JapaneseTokenizer using the system and unknown dictionaries shipped with Lucene.

Parameters:

factory - the AttributeFactory to use

userDictionary - Optional: if non-null, user dictionary.

discardPunctuation - true if punctuation tokens should be dropped from the output.

discardCompoundToken - true if compound tokens should be dropped from the output when tokenization mode is not NORMAL.

mode - tokenization mode.

JapaneseTokenizer

public JapaneseTokenizer(AttributeFactory factory,
                         TokenInfoDictionary systemDictionary,
                         UnknownDictionary unkDictionary,
                         ConnectionCosts connectionCosts,
                         UserDictionary userDictionary,
                         boolean discardPunctuation,
                         boolean discardCompoundToken,
                         JapaneseTokenizer.Mode mode)

Create a new JapaneseTokenizer, supplying a custom system dictionary and unknown dictionary. This constructor provides an entry point for users that want to construct custom language models that can be used as input to DictionaryBuilder.

Parameters:

factory - the AttributeFactory to use

systemDictionary - a custom known token dictionary

unkDictionary - a custom unknown token dictionary

connectionCosts - custom token transition costs

userDictionary - Optional: if non-null, user dictionary.

discardPunctuation - true if punctuation tokens should be dropped from the output.

discardCompoundToken - true if compound tokens should be dropped from the output when tokenization mode is not NORMAL.

mode - tokenization mode.

Method Detail

setGraphvizFormatter

public void setGraphvizFormatter(GraphvizFormatter dotOut)

Expert: set this to produce graphviz (dot) output of the Viterbi lattice

close

public void close()
           throws java.io.IOException

Description copied from class: Tokenizer

Releases resources associated with this stream.

If you override this method, always call super.close(), otherwise some internal state will not be correctly reset (e.g., Tokenizer will throw IllegalStateException on reuse).

NOTE: The default implementation closes the input Reader, so be sure to call super.close() when overriding this method.

Specified by:

close in interface java.lang.AutoCloseable

Specified by:

close in interface java.io.Closeable

Overrides:

close in class Tokenizer

Throws:

java.io.IOException

reset

public void reset()
           throws java.io.IOException

Description copied from class: TokenStream

This method is called by a consumer before it begins consumption using TokenStream.incrementToken().

Resets this stream to a clean state. Stateful implementations must implement this method so that they can be reused, just as if they had been created fresh.

If you override this method, always call super.reset(), otherwise some internal state will not be correctly reset (e.g., Tokenizer will throw IllegalStateException on further usage).

Overrides:

reset in class Tokenizer

Throws:

java.io.IOException

resetState

private void resetState()

end

public void end()
         throws java.io.IOException

Description copied from class: TokenStream

This method is called by the consumer after the last token has been consumed, after TokenStream.incrementToken() returned false (using the new TokenStream API). Streams implementing the old API should upgrade to use this feature.

This method can be used to perform any end-of-stream operations, such as setting the final offset of a stream. The final offset of a stream might differ from the offset of the last token eg in case one or more whitespaces followed after the last token, but a WhitespaceTokenizer was used.

Additionally any skipped positions (such as those removed by a stopfilter) can be applied to the position increment, or any adjustment of other attributes where the end-of-stream value may be important.

If you override this method, always call super.end().

Overrides:

end in class TokenStream

Throws:

java.io.IOException - If an I/O error occurs

computeSecondBestThreshold

private int computeSecondBestThreshold(int pos,
                                       int length)
                                throws java.io.IOException

Throws:

java.io.IOException

computePenalty

private int computePenalty(int pos,
                           int length)
                    throws java.io.IOException

Throws:

java.io.IOException

add

private void add(Dictionary dict,
                 JapaneseTokenizer.Position fromPosData,
                 int endPos,
                 int wordID,
                 JapaneseTokenizer.Type type,
                 boolean addPenalty)
          throws java.io.IOException

Throws:

java.io.IOException

incrementToken

public boolean incrementToken()
                       throws java.io.IOException

Description copied from class: TokenStream

Consumers (i.e., IndexWriter) use this method to advance the stream to the next token. Implementing classes must implement this method and update the appropriate AttributeImpls with the attributes of the next token.

The producer must make no assumptions about the attributes after the method has been returned: the caller may arbitrarily change it. If the producer needs to preserve the state for subsequent calls, it can use AttributeSource.captureState() to create a copy of the current attribute state.

This method is called for every token of a document, so an efficient implementation is crucial for good performance. To avoid calls to AttributeSource.addAttribute(Class) and AttributeSource.getAttribute(Class), references to all AttributeImpls that this stream uses should be retrieved during instantiation.

To ensure that filters and consumers know which attributes are available, the attributes must be added during instantiation. Filters and consumers are not required to check for availability of attributes in TokenStream.incrementToken().

Specified by:

incrementToken in class TokenStream

Returns:

false for end of stream; true otherwise

Throws:

java.io.IOException

parse

private void parse()
            throws java.io.IOException

Throws:

java.io.IOException

pruneAndRescore

private void pruneAndRescore(int startPos,
                             int endPos,
                             int bestStartIDX)
                      throws java.io.IOException

Throws:

java.io.IOException

registerNode

private void registerNode(int node,
                          char[] fragment)

fixupPendingList

private void fixupPendingList()

probeDelta

private int probeDelta(java.lang.String inText,
                       java.lang.String requiredToken)
                throws java.io.IOException

Throws:

java.io.IOException

calcNBestCost

public int calcNBestCost(java.lang.String examples)

setNBestCost

public void setNBestCost(int value)

backtraceNBest

private void backtraceNBest(JapaneseTokenizer.Position endPosData,
                            boolean useEOS)
                     throws java.io.IOException

Throws:

java.io.IOException

backtrace

private void backtrace(JapaneseTokenizer.Position endPosData,
                       int fromIDX)
                throws java.io.IOException

Throws:

java.io.IOException

getDict

Dictionary getDict(JapaneseTokenizer.Type type)

isPunctuation

private static boolean isPunctuation(char ch)