KOMORAN (KOrean MORphological ANalyzer)

KOMORAN (KOrean MORphical ANalyzer) is a morphological analyzer for the Korean language developed in Java. It is designed to be lightweight, easy to use, and highly portable.

Key Features

• Pure Java: Since it is 100% Java, it can be used in any environment where Java is installed.
• Zero External Dependencies: It uses only internally developed libraries, avoiding dependency conflicts with other external libraries.
• Lightweight: It can operate with approximately 50MB of memory thanks to its use of TRIE dictionaries and character-unit processing.
• Easy to Use: Once the library is integrated, the analyzer can be invoked with a single line of code.
• Easy Dictionary Management: Dictionaries are composed of plain text files, making them highly readable and easy to edit.
• Advanced Analysis Results: Unlike other morphological analyzers, KOMORAN can perform analysis on morpheme units that include whitespace.

KOMORAN (KOrean MORphological ANalyzer) is a Korean morphological analyzer implemented entirely in Java. It is designed to be lightweight, easy to use, and independent of external libraries.

Key Features:

• Pure Java Implementation: Works in any environment with a Java Runtime Environment (JRE).
• Zero External Dependencies: Uses only internally developed libraries to avoid dependency conflicts.
• Lightweight: Capable of operating with approximately 50MB of memory using Trie dictionaries and character-unit processing.
• Ease of Use: Can be integrated into source code with minimal effort (typically a single line of code after library application).
• Easy Dictionary Management: Dictionaries are stored as highly readable plain text files for easy editing.
• Advanced Analysis: Supports morphological analysis that includes whitespace-separated units, distinguishing it from other analyzers.

KOMORAN provides two pre-trained Part-of-Speech (POS) tagging models. Starting from version 3.4, the previous FULL and LIGHT models have been renamed to STABLE and EXP respectively.

STABLE Model

• Training Data: Trained on a subset of the Sejong Corpus and additional collected data.
• Best Use Case: General-purpose use for everyday sentences across various domains.
• Recommendation: Use this model for most applications, especially if the morphological analysis results are exposed directly to end-users in a service.
• Maintenance: This model is continuously managed by SHINEWARE.

EXP Model

• Training Data: Built upon the STABLE model's training data, with additional nouns extracted from Wikipedia titles.
• Best Use Case: Domains where neologisms (newly coined words) and proper nouns are critical, such as news classification or SNS (social media) data analysis.
• Caution: Nouns extracted from Wikipedia titles have not been verified and may contain inaccuracies.

Models are stored in the models/ directory under the project root. Each subdirectory represents a single model, named after its creation timestamp. A model directory contains the following structure:

• corpus_build/: Base data used to generate user models.
  • dic.irregular: Irregular dictionary.
  • dic.word: Word frequency dictionary.
  • grammar.in: PoS frequency dictionary.
• dic.user: User word dictionary.
• fwd.user: Pre-analyzed dictionary.
• model/: The generated user model containing:
  • irregular.model
  • observation.model
  • pos.table
  • transition.model

.
├── corpus_build        # 사용자 모델을 생성하기 위한 기초 데이터
│   ├── dic.irregular   # 불규칙 사전
│   ├── dic.word        # 단어 빈도 사전
│   └── grammar.in      # 품사 빈도 사전
├── dic.user            # 사용자 단어 사전
├── fwd.user            # 기분석 사전
└── model               # 위 corpus_build/ 디렉토리 내의 데이터로 생성한 사용자 모델
    ├── irregular.model
    ├── observation.model
    ├── pos.table
    └── transition.model

If you are not using a build tool like Gradle or Maven, you can use KOMORAN by manually adding the JAR file to your classpath.

Project Structure

Ensure your project is organized as follows:

.
├── App.java
└── libs
    └── KOMORAN-3.3.9.jar

1. Add Dependency

Create a libs directory and place the KOMORAN-3.3.9.jar file inside it.

2. Implement Analysis

Use the Komoran class to perform analysis. You must initialize it with a model type (e.g., DEFAULT_MODEL.EXPERIMENT). The analyze() method returns a KomoranResult object, which provides access to the tagged plain text and a list of Token objects.

3. Compile and Run

To compile App.java with the KOMORAN JAR in the classpath:

javac -cp "./libs/KOMORAN-3.3.9.jar:" App.java

To run the compiled class:

java -cp ".:./libs/KOMORAN-3.3.9.jar:" App

import kr.co.shineware.nlp.komoran.constant.DEFAULT_MODEL;
import kr.co.shineware.nlp.komoran.core.Komoran;
import kr.co.shineware.nlp.komoran.model.KomoranResult;
import kr.co.shineware.nlp.komoran.model.Token;

import java.util.List;

public class App {
  public static void main(String[] args){
    Komoran komoran = new Komoran(DEFAULT_MODEL.EXPERIMENT);
    String strToAnalyze = "대한민국은 민주공화국이다.";

    KomoranResult analyzeResultList = komoran.analyze(strToAnalyze);

    System.out.println(analyzeResultList.getPlainText());

    List<Token> tokenList = analyzeResultList.getTokenList();
    for (Token token : tokenList) {
        System.out.format("(%2d, %2d) %s/%s\n", token.getBeginIndex(), token.getEndIndex(), token.getMorph(), token.getPos());
    }
  }
}