tokmor 1.2.9__py3-none-any.whl

tokmor/morphology/hindi_advanced.py

@@ -0,0 +1,258 @@
+"""
+Hindi Advanced Morphological Analyzer
+=====================================
+
+5가지 고급 기능을 지원하는 힌디어 형태소 분석기
+
+특징:
+- 데바나가리 문자 처리
+- 후치사 분리
+- 동사 활용 분석
+"""
+
+import re
+from typing import List, Tuple, Dict, Optional
+
+from .advanced_base import (
+    AdvancedMorphologicalAnalyzer, Morpheme, AnalysisResult, NBestResult, Domain
+)
+
+
+class HindiAdvancedAnalyzer(AdvancedMorphologicalAnalyzer):
+    """힌디어 고급 형태소 분석기"""
+
+    LANG_CODE = "hi"
+    LANG_NAME = "Hindi"
+
+    # 데바나가리 문자 패턴
+    DEVANAGARI_PATTERN = re.compile(r'[\u0900-\u097F]+')
+    NUMBER_PATTERN = re.compile(r'[0-9०-९]+(?:[.,][0-9०-९]+)?')
+
+    def __init__(self):
+        super().__init__()
+
+    def _build_base_dictionary(self):
+        """기본 사전 구축"""
+
+        # 후치사 (Postpositions)
+        self.postpositions = {
+            'का': 'PSP', 'की': 'PSP', 'के': 'PSP',  # ~의
+            'को': 'PSP',  # ~에게
+            'से': 'PSP',  # ~로부터
+            'में': 'PSP', # ~안에
+            'पर': 'PSP',  # ~위에
+            'तक': 'PSP',  # ~까지
+            'लिए': 'PSP', # ~을 위해
+            'साथ': 'PSP', # ~와 함께
+            'बिना': 'PSP', # ~없이
+            'द्वारा': 'PSP', # ~에 의해
+            'बारे': 'PSP', # ~에 대해
+            'ने': 'PSP',  # 행위자 표지
+        }
+
+        # 대명사
+        self.pronouns = {
+            'मैं': 'PRON', 'तू': 'PRON', 'तुम': 'PRON', 'आप': 'PRON',
+            'वह': 'PRON', 'यह': 'PRON', 'वे': 'PRON', 'ये': 'PRON',
+            'हम': 'PRON', 'वो': 'PRON',
+            'मुझे': 'PRON', 'तुझे': 'PRON', 'उसे': 'PRON', 'इसे': 'PRON',
+            'हमें': 'PRON', 'उन्हें': 'PRON', 'इन्हें': 'PRON',
+            'मेरा': 'PRON', 'तेरा': 'PRON', 'उसका': 'PRON', 'इसका': 'PRON',
+            'कौन': 'PRON', 'क्या': 'PRON', 'कहाँ': 'PRON', 'कब': 'PRON',
+            'जो': 'REL', 'जिसे': 'REL', 'जिसको': 'REL',
+        }
+
+        # 접속사
+        self.conjunctions = {
+            'और': 'CONJ', 'या': 'CONJ', 'लेकिन': 'CONJ', 'परंतु': 'CONJ',
+            'कि': 'CONJ', 'क्योंकि': 'CONJ', 'अगर': 'CONJ', 'यदि': 'CONJ',
+            'जब': 'CONJ', 'तो': 'CONJ', 'तब': 'CONJ', 'फिर': 'CONJ',
+            'इसलिए': 'CONJ', 'जबकि': 'CONJ', 'हालांकि': 'CONJ',
+        }
+
+        # 부사
+        self.adverbs = {
+            'बहुत': 'ADV', 'अच्छी': 'ADV', 'तरह': 'ADV', 'जल्दी': 'ADV',
+            'धीरे': 'ADV', 'अभी': 'ADV', 'अब': 'ADV', 'कल': 'ADV',
+            'आज': 'ADV', 'फिर': 'ADV', 'यहाँ': 'ADV', 'वहाँ': 'ADV',
+            'कभी': 'ADV', 'हमेशा': 'ADV', 'कभी': 'ADV', 'बस': 'ADV',
+            'सिर्फ': 'ADV', 'भी': 'ADV', 'ही': 'ADV', 'तो': 'ADV',
+        }
+
+        # 부정어/불변화사
+        self.particles = {
+            'नहीं': 'NEG', 'न': 'NEG', 'मत': 'NEG',
+            'ही': 'PRT', 'भी': 'PRT', 'तो': 'PRT',
+            'जी': 'PRT', 'हाँ': 'PRT',
+        }
+
+        # 조동사
+        self.auxiliaries = {
+            'है': 'AUX', 'हैं': 'AUX', 'था': 'AUX', 'थी': 'AUX', 'थे': 'AUX', 'थीं': 'AUX',
+            'हूँ': 'AUX', 'हो': 'AUX',
+            'रहा': 'AUX', 'रही': 'AUX', 'रहे': 'AUX',
+            'गया': 'AUX', 'गयी': 'AUX', 'गए': 'AUX',
+            'सकता': 'AUX', 'सकती': 'AUX', 'सकते': 'AUX',
+            'चाहिए': 'AUX', 'होगा': 'AUX', 'होगी': 'AUX',
+        }
+
+        # 일반 명사 (고빈도)
+        self.common_nouns = {
+            'लोग': 'NC', 'आदमी': 'NC', 'औरत': 'NC', 'बच्चा': 'NC',
+            'घर': 'NC', 'काम': 'NC', 'समय': 'NC', 'दिन': 'NC',
+            'साल': 'NC', 'बात': 'NC', 'पानी': 'NC', 'खाना': 'NC',
+            'देश': 'NC', 'शहर': 'NC', 'सरकार': 'NC', 'कंपनी': 'NC',
+        }
+
+        # 동사 어간 (고빈도)
+        self.verb_stems = {
+            'कर': 'V', 'हो': 'V', 'जा': 'V', 'आ': 'V', 'दे': 'V',
+            'ले': 'V', 'रह': 'V', 'बोल': 'V', 'कह': 'V', 'सुन': 'V',
+            'देख': 'V', 'खा': 'V', 'पी': 'V', 'लिख': 'V', 'पढ़': 'V',
+            'चल': 'V', 'बैठ': 'V', 'उठ': 'V', 'सो': 'V', 'मिल': 'V',
+        }
+
+    def _build_domain_dictionaries(self):
+        """도메인별 사전"""
+        self._domain_dictionaries[Domain.TECH] = {
+            'सेब': ('Apple', 'NP'),  # Apple company
+            'बादल': ('cloud', 'NC'),  # cloud computing
+        }
+        self._domain_dictionaries[Domain.FOOD] = {
+            'सेब': ('सेब', 'NC'),  # apple (fruit)
+        }
+        self._domain_dictionaries[Domain.FINANCE] = {
+            'बैंक': ('बैंक', 'NC'),  # bank
+            'शेयर': ('शेयर', 'NC'),  # stock
+        }
+
+    def _generate_candidates(self, text: str, domain: Domain) -> List[AnalysisResult]:
+        if not text or not text.strip():
+            return [AnalysisResult([])]
+        morphemes = self._analyze_text(text, domain)
+        result = AnalysisResult(morphemes=morphemes, score=1.0, domain=domain)
+        result.score = self._score_analysis(result)
+        return [result]
+
+    def _analyze_text(self, text: str, domain: Domain) -> List[Morpheme]:
+        result = []
+        pos = 0
+        while pos < len(text):
+            if text[pos].isspace():
+                pos += 1
+                continue
+
+            devanagari_match = self.DEVANAGARI_PATTERN.match(text[pos:])
+            if devanagari_match:
+                word = devanagari_match.group()
+                morpheme = self._analyze_word(word, pos, domain)
+                result.append(morpheme)
+                pos += len(word)
+                continue
+
+            # 라틴 문자 (영어 차용어)
+            latin_match = re.match(r'[a-zA-Z]+', text[pos:])
+            if latin_match:
+                word = latin_match.group()
+                result.append(Morpheme(surface=word, lemma=word, pos='FOREIGN', start=pos, end=pos + len(word)))
+                pos += len(word)
+                continue
+
+            num_match = self.NUMBER_PATTERN.match(text[pos:])
+            if num_match:
+                num = num_match.group()
+                result.append(Morpheme(surface=num, lemma=num, pos='NUM', start=pos, end=pos + len(num)))
+                pos += len(num)
+                continue
+
+            result.append(Morpheme(surface=text[pos], lemma=text[pos], pos='PUNCT', start=pos, end=pos + 1))
+            pos += 1
+        return result
+
+    def _analyze_word(self, word: str, offset: int, domain: Domain) -> Morpheme:
+        """단어 분석"""
+
+        # 런타임 사전
+        if word in self._user_dictionary:
+            lemma, pos_tag, _ = self._user_dictionary[word]
+            return Morpheme(surface=word, lemma=lemma, pos=pos_tag, start=offset, end=offset + len(word))
+
+        # 도메인 사전
+        domain_sense = self._get_domain_sense(word, domain)
+        if domain_sense:
+            return Morpheme(surface=word, lemma=domain_sense[0], pos=domain_sense[1], start=offset, end=offset + len(word))
+
+        # 후치사
+        if word in self.postpositions:
+            return Morpheme(surface=word, lemma=word, pos='PSP', start=offset, end=offset + len(word))
+
+        # 대명사
+        if word in self.pronouns:
+            return Morpheme(surface=word, lemma=word, pos='PRON', start=offset, end=offset + len(word))
+
+        # 접속사
+        if word in self.conjunctions:
+            return Morpheme(surface=word, lemma=word, pos='CONJ', start=offset, end=offset + len(word))
+
+        # 부사
+        if word in self.adverbs:
+            return Morpheme(surface=word, lemma=word, pos='ADV', start=offset, end=offset + len(word))
+
+        # 불변화사
+        if word in self.particles:
+            return Morpheme(surface=word, lemma=word, pos=self.particles[word], start=offset, end=offset + len(word))
+
+        # 조동사
+        if word in self.auxiliaries:
+            return Morpheme(surface=word, lemma=word, pos='AUX', start=offset, end=offset + len(word))
+
+        # 일반명사
+        if word in self.common_nouns:
+            return Morpheme(surface=word, lemma=word, pos='NC', start=offset, end=offset + len(word))
+
+        # 동사 어간 확인
+        for stem, pos_tag in self.verb_stems.items():
+            if word.startswith(stem) and len(word) > len(stem):
+                return Morpheme(surface=word, lemma=stem, pos='V', start=offset, end=offset + len(word))
+
+        # 형태 분석
+        lemma, pos_tag = self._analyze_morphology(word)
+        return Morpheme(surface=word, lemma=lemma, pos=pos_tag, start=offset, end=offset + len(word))
+
+    def _analyze_morphology(self, word: str) -> Tuple[str, str]:
+        """형태 분석"""
+        # -ना 동사 원형
+        if word.endswith('ना') and len(word) > 2:
+            return (word, 'V')
+
+        # -ता/-ती/-ते 현재분사
+        if word.endswith(('ता', 'ती', 'ते')) and len(word) > 2:
+            return (word[:-1], 'V')
+
+        # -ा/-ी/-े 과거분사
+        if word.endswith(('ा', 'ी', 'े')) and len(word) > 2:
+            return (word[:-1], 'V')
+
+        # -ई 명사 (여성)
+        if word.endswith('ई') and len(word) > 2:
+            return (word, 'NC')
+
+        # -आ 명사 (남성)
+        if word.endswith('आ') and len(word) > 2:
+            return (word, 'NC')
+
+        # 기본값: 명사
+        return (word, 'NC')
+
+    def _generate_alternatives(self, text: str, domain: Domain, count: int) -> List[AnalysisResult]:
+        alternatives = []
+        other_domains = [d for d in Domain if d != domain][:count]
+        for alt_domain in other_domains:
+            morphemes = self._analyze_text(text, alt_domain)
+            result = AnalysisResult(morphemes=morphemes, score=0.8, domain=alt_domain)
+            result.score = self._score_analysis(result) * 0.9
+            alternatives.append(result)
+        return alternatives
+
+
+HindiAnalyzer = HindiAdvancedAnalyzer

tokmor/morphology/japanese.py

@@ -0,0 +1,417 @@
+"""
+Japanese Morphological Analyzer - 자체 구현
+===========================================
+
+외부 라이브러리 없이 순수 Python으로 구현한 일본어 형태소 분석기.
+
+옵션 자산(고ROI):
+- `TOKMOR_DATA_DIR/seg_lexicon/ja_wordfreq.pkl` 가 있으면, 긴 한자 run을
+  보수적으로 분할하기 위한 Viterbi 후보 점수로 사용한다.
+  (코어에는 자산을 번들하지 않음)
+"""
+
+import re
+import math
+import pickle
+from typing import List, Tuple, Optional
+from dataclasses import dataclass
+
+from ..resources import resolve_seg_lexicon_path
+
+
+@dataclass
+class Morpheme:
+    """형태소"""
+    surface: str
+    lemma: str
+    pos: str
+    start: int
+    end: int
+    reading: str = ''
+
+    def __repr__(self):
+        return f"{self.surface}/{self.pos}"
+
+
+class JapaneseAnalyzer:
+    """
+    일본어 형태소 분석기
+
+    Usage:
+        analyzer = JapaneseAnalyzer()
+        result = analyzer.analyze("東京に行きます")
+    """
+
+    def __init__(self):
+        # Optional kanji wordfreq lexicon (offline): {token:freq}
+        self._wordfreq = None
+        self._wordfreq_max_len = 4
+        self._build_dictionary()
+        self._load_seg_lexicon()
+
+    def _build_dictionary(self):
+        """사전 구축"""
+
+        # 조사
+        self.particles = {
+            'は': 'HA', 'が': 'GA', 'を': 'WO', 'に': 'NI', 'へ': 'HE',
+            'で': 'DE', 'と': 'TO', 'から': 'KARA', 'まで': 'MADE',
+            'より': 'YORI', 'の': 'NO', 'も': 'MO', 'や': 'YA',
+            'など': 'NADO', 'か': 'KA', 'ね': 'NE', 'よ': 'YO',
+        }
+
+        # 조동사/어미
+        self.auxiliaries = {
+            'です': 'AUX', 'ます': 'AUX', 'た': 'AUX', 'だ': 'AUX',
+            'ない': 'AUX', 'れる': 'AUX', 'られる': 'AUX',
+            'せる': 'AUX', 'させる': 'AUX', 'たい': 'AUX',
+            'ている': 'AUX', 'てる': 'AUX', 'ました': 'AUX',
+        }
+
+        # 명사
+        self.nouns = {
+            '東京': ('名詞', 'トウキョウ'), '日本': ('名詞', 'ニホン'),
+            '大阪': ('名詞', 'オオサカ'), '京都': ('名詞', 'キョウト'),
+            '会社': ('名詞', 'カイシャ'), '学校': ('名詞', 'ガッコウ'),
+            '仕事': ('名詞', 'シゴト'), '人': ('名詞', 'ヒト'),
+            '時間': ('名詞', 'ジカン'), '今日': ('名詞', 'キョウ'),
+            '明日': ('名詞', 'アシタ'), '昨日': ('名詞', 'キノウ'),
+            '私': ('名詞', 'ワタシ'), '彼': ('名詞', 'カレ'),
+            '発表': ('名詞', 'ハッピョウ'), '自動車': ('名詞', 'ジドウシャ'),
+        }
+
+        # 動詞 (5段/1段/カ変/サ変)
+        self.verbs = {
+            '行': ('動詞', '行く', 'godan'),
+            '来': ('動詞', '来る', 'kuru'),
+            '見': ('動詞', '見る', 'ichidan'),
+            '食': ('動詞', '食べる', 'ichidan'),
+            '話': ('動詞', '話す', 'godan'),
+            '読': ('動詞', '読む', 'godan'),
+            '書': ('動詞', '書く', 'godan'),
+            '聞': ('動詞', '聞く', 'godan'),
+            '思': ('動詞', '思う', 'godan'),
+            '言': ('動詞', '言う', 'godan'),
+            'し': ('動詞', 'する', 'suru'),
+            'する': ('動詞', 'する', 'suru'),
+        }
+
+        # 형용사 (어간 + 종지형 모두 등록)
+        self.adjectives = {
+            # イ形容詞 어간
+            '大き': ('形容詞', '大きい'),
+            '小さ': ('形容詞', '小さい'),
+            '高': ('形容詞', '高い'),
+            '安': ('形容詞', '安い'),
+            '新し': ('形容詞', '新しい'),
+            '古': ('形容詞', '古い'),
+            '良': ('形容詞', '良い'),
+            '悪': ('形容詞', '悪い'),
+            '長': ('形容詞', '長い'),
+            '短': ('形容詞', '短い'),
+            '早': ('形容詞', '早い'),
+            '遅': ('形容詞', '遅い'),
+            '強': ('形容詞', '強い'),
+            '弱': ('形容詞', '弱い'),
+            '多': ('形容詞', '多い'),
+            '少な': ('形容詞', '少ない'),
+            '美し': ('形容詞', '美しい'),
+            '難し': ('形容詞', '難しい'),
+            '易し': ('形容詞', '易しい'),
+            # イ形容詞 종지형
+            '大きい': ('形容詞', '大きい'),
+            '小さい': ('形容詞', '小さい'),
+            '高い': ('形容詞', '高い'),
+            '安い': ('形容詞', '安い'),
+            '新しい': ('形容詞', '新しい'),
+            '古い': ('形容詞', '古い'),
+            '良い': ('形容詞', '良い'),
+            '悪い': ('形容詞', '悪い'),
+            '長い': ('形容詞', '長い'),
+            '短い': ('形容詞', '短い'),
+            '早い': ('形容詞', '早い'),
+            '遅い': ('形容詞', '遅い'),
+            '強い': ('形容詞', '強い'),
+            '弱い': ('形容詞', '弱い'),
+            '多い': ('形容詞', '多い'),
+            '少ない': ('形容詞', '少ない'),
+            '美しい': ('形容詞', '美しい'),
+            '難しい': ('形容詞', '難しい'),
+            '易しい': ('形容詞', '易しい'),
+        }
+
+        # 히라가나 범위
+        self.hiragana = re.compile(r'[\u3040-\u309f]+')
+        # 가타카나 범위
+        self.katakana = re.compile(r'[\u30a0-\u30ff]+')
+        # 한자 범위
+        self.kanji = re.compile(r'[\u4e00-\u9fff]+')
+
+    def _load_seg_lexicon(self) -> None:
+        p = resolve_seg_lexicon_path("ja")
+        if not p:
+            return
+        try:
+            obj = pickle.loads(p.read_bytes())
+            if not isinstance(obj, dict):
+                return
+            wf = {}
+            mx = 2
+            for k, v in obj.items():
+                if isinstance(k, str) and k and isinstance(v, int) and v > 0:
+                    # Japanese kanji-only lexicon expected; keep it conservative
+                    if len(k) < 2:
+                        continue
+                    wf[k] = int(v)
+                    if len(k) > mx:
+                        mx = len(k)
+            if wf:
+                self._wordfreq = wf
+                self._wordfreq_max_len = max(2, min(int(mx), 8))
+        except Exception:
+            return
+
+    def _viterbi_kanji_run(self, run: str, start: int) -> List[Morpheme]:
+        """
+        Viterbi segmentation over a pure-Kanji run using optional wordfreq.
+        If lexicon is missing, caller should not use this.
+        """
+        wf = self._wordfreq or {}
+        max_len = max(self._wordfreq_max_len, 4)
+        max_len = max(2, min(int(max_len), 8))
+        n = len(run)
+
+        # Conservative scoring: prefer longer spans, penalize 1-char, reward known spans.
+        len_bonus = 0.75
+        single_penalty = 1.2
+        unk_base = -1.6
+        unk_len_penalty = 0.35
+        freq_cap = 200_000
+
+        best = [-1e100] * (n + 1)
+        back = [-1] * (n + 1)
+        back_len = [1] * (n + 1)
+        best[0] = 0.0
+
+        for i in range(n):
+            if best[i] <= -1e90:
+                continue
+            # allow 1..max_len
+            for L in range(1, max_len + 1):
+                j = i + L
+                if j > n:
+                    break
+                span = run[i:j]
+                f = wf.get(span)
+                if f is not None:
+                    f2 = min(int(f), freq_cap)
+                    s = best[i] + math.log(f2 + 1.0) + len_bonus * (L - 1)
+                    if L == 1:
+                        s -= single_penalty
+                else:
+                    # unknown: allow grouping, but penalize longer unknown spans
+                    s = best[i] + unk_base - unk_len_penalty * (L - 1)
+                    if L == 1:
+                        s -= single_penalty
+
+                if s > best[j]:
+                    best[j] = s
+                    back[j] = i
+                    back_len[j] = L
+
+        # backtrack
+        out: List[Morpheme] = []
+        j = n
+        if best[j] <= -1e90:
+            # fallback: whole run
+            return [Morpheme(run, run, '名詞', start, start + n)]
+
+        while j > 0:
+            i = back[j]
+            L = back_len[j]
+            if i < 0:
+                break
+            span = run[i:j]
+            out.append(Morpheme(span, span, '名詞', start + i, start + j))
+            j = i
+        out.reverse()
+        return out
+
+    def analyze(self, text: str) -> List[Morpheme]:
+        """형태소 분석"""
+        if not text:
+            return []
+
+        result = []
+        pos = 0
+
+        while pos < len(text):
+            matched = False
+
+            # 공백
+            if text[pos].isspace():
+                pos += 1
+                continue
+
+            # 한자 연속 확인 (인명/고유명사 우선)
+            # 2자 이상 한자 연속이면 먼저 인명으로 처리
+            if self.kanji.match(text[pos]):
+                kanji_match = self.kanji.match(text[pos:])
+                kanji_chunk = kanji_match.group()
+                # 2자 이상 한자 연속 + 다음 문자가 조사이면 고유명사로 처리
+                next_pos = pos + len(kanji_chunk)
+                if len(kanji_chunk) >= 2:
+                    if next_pos >= len(text) or text[next_pos] in self.particles or text[next_pos].isspace():
+                        # 먼저 사전에서 찾기
+                        found_in_dict = False
+                        for l in range(len(kanji_chunk), 0, -1):
+                            if text[pos:pos+l] in self.nouns:
+                                info = self.nouns[text[pos:pos+l]]
+                                result.append(Morpheme(
+                                    text[pos:pos+l], text[pos:pos+l], info[0],
+                                    pos, pos + l, info[1]
+                                ))
+                                pos += l
+                                found_in_dict = True
+                                matched = True
+                                break
+                        if found_in_dict:
+                            continue
+                        # Optional: if we have a kanji lexicon, split long runs *only when it clearly helps*.
+                        if self._wordfreq and len(kanji_chunk) >= 6:
+                            parts = self._viterbi_kanji_run(kanji_chunk, pos)
+                            # accept only if we got multiple non-trivial parts (avoid over-fragmentation)
+                            if len(parts) >= 2 and all(len(p.surface) >= 2 for p in parts):
+                                result.extend(parts)
+                                pos += len(kanji_chunk)
+                                matched = True
+                                continue
+
+                        # 사전에 없으면 전체를 고유명사로
+                        result.append(Morpheme(
+                            kanji_chunk, kanji_chunk, '固有名詞',
+                            pos, pos + len(kanji_chunk)
+                        ))
+                        pos += len(kanji_chunk)
+                        matched = True
+                        continue
+
+            # 최장일치로 사전 탐색
+            for length in range(min(len(text) - pos, 10), 0, -1):
+                substring = text[pos:pos+length]
+
+                # 형용사 (명사보다 먼저 확인) - 단독 형용사만
+                if substring in self.adjectives and length > 1:
+                    info = self.adjectives[substring]
+                    result.append(Morpheme(
+                        substring, info[1], '形容詞',
+                        pos, pos + length
+                    ))
+                    pos += length
+                    matched = True
+                    break
+
+                # 명사
+                if substring in self.nouns:
+                    info = self.nouns[substring]
+                    result.append(Morpheme(
+                        substring, substring, info[0],
+                        pos, pos + length, info[1]
+                    ))
+                    pos += length
+                    matched = True
+                    break
+
+                # 조사
+                if substring in self.particles:
+                    result.append(Morpheme(
+                        substring, substring, '助詞',
+                        pos, pos + length
+                    ))
+                    pos += length
+                    matched = True
+                    break
+
+                # 조동사
+                if substring in self.auxiliaries:
+                    result.append(Morpheme(
+                        substring, substring, '助動詞',
+                        pos, pos + length
+                    ))
+                    pos += length
+                    matched = True
+                    break
+
+            if not matched:
+                # 한자 청크
+                if self.kanji.match(text[pos]):
+                    match = self.kanji.match(text[pos:])
+                    chunk = match.group()
+                    # If we have a kanji wordfreq lexicon, split long runs conservatively.
+                    if self._wordfreq and len(chunk) >= 5:
+                        result.extend(self._viterbi_kanji_run(chunk, pos))
+                    else:
+                        result.append(Morpheme(
+                            chunk, chunk, '名詞',
+                            pos, pos + len(chunk)
+                        ))
+                    pos += len(chunk)
+                # 히라가나 청크
+                elif self.hiragana.match(text[pos]):
+                    match = self.hiragana.match(text[pos:])
+                    chunk = match.group()
+                    # 동사 활용 분석 시도
+                    analyzed = self._analyze_verb_form(chunk, pos)
+                    if analyzed:
+                        result.extend(analyzed)
+                    else:
+                        result.append(Morpheme(
+                            chunk, chunk, '名詞',
+                            pos, pos + len(chunk)
+                        ))
+                    pos += len(chunk)
+                # 가타카나 청크 (외래어)
+                elif self.katakana.match(text[pos]):
+                    match = self.katakana.match(text[pos:])
+                    chunk = match.group()
+                    result.append(Morpheme(
+                        chunk, chunk, '名詞',
+                        pos, pos + len(chunk)
+                    ))
+                    pos += len(chunk)
+                else:
+                    # 기타 (숫자, 기호 등)
+                    result.append(Morpheme(
+                        text[pos], text[pos], '記号',
+                        pos, pos + 1
+                    ))
+                    pos += 1
+
+        return result
+
+    def _analyze_verb_form(self, form: str, offset: int) -> List[Morpheme]:
+        """동사 활용형 분석"""
+        results = []
+
+        # ます형
+        if form.endswith('ます'):
+            stem = form[:-2]
+            if stem:
+                results.append(Morpheme(stem, stem + 'る', '動詞', offset, offset + len(stem)))
+                results.append(Morpheme('ます', 'ます', '助動詞', offset + len(stem), offset + len(form)))
+                return results
+
+        # た형
+        if form.endswith('た') or form.endswith('だ'):
+            stem = form[:-1]
+            if stem:
+                results.append(Morpheme(stem, stem, '動詞', offset, offset + len(stem)))
+                results.append(Morpheme(form[-1], form[-1], '助動詞', offset + len(stem), offset + len(form)))
+                return results
+
+        return []
+
+    def pos_tag(self, text: str) -> List[Tuple[str, str]]:
+        """품사 태깅"""
+        morphemes = self.analyze(text)
+        return [(m.surface, m.pos) for m in morphemes]