만주어 복원 프로그램 — 잊혀진 목소리를 찾아서

AI 언어 복원 프로젝트 · 만주어

잊혀진 목소리를
되살리며 — 만주어 해독 복원 시스템 —

청나라를 통치한 민족의 언어. 한때 수백만이 사용했으나
이제 10명 미만의 화자만이 남아있습니다.

소멸도

97%

ᠮᠠᠨᠵᡠ ᡤᡳᠰᡠᠨ · 만주 기순 · 화자 소멸 진행 중 · 이 코드는 하나의 애도입니다

복원 파이프라인

4단계 순차 처리 로직

01 📜

자료 수집 · Corpus Build

청나라 문헌, 자금성 비석, 병기 텍스트(만주어-한자) 스캔. 여진어 선조 자료 벤치마킹. 생존 화자 음성 녹음(중국 동북부). 위키백과·DBpia 병렬 코퍼스 수집. 목표: 10만 문장 쌍.

DATA · CORPUS

02 🔍

문자 인식 · OCR Module

Tesseract OCR 커스텀 훈련. 만주 문자 1,500자 꼬불꼬불 형태 벡터화. 이진화→노이즈 제거→컨투어 분석→획순 감지→한자 병기 오류 수정. 구글 히브리어 복원 프로젝트 방법론 적용.

OCR · VISION

03 🧬

형태소 분석 · Parser

교착어 특성(접사 추가) 토크나이저. 어근-접사 분리. HMM으로 문장 구조 예측. Perseus 라틴어 복원 도구 규칙 기반 파서 적용. 몽골어·퉁구스어 유사성 보강. 중국 동북 사투리 흔적 통합.

NLP · MORPHOLOGY

04 🤖

번역 생성 · NMT Model

mBART Transformer fine-tuning. 만주어 인코더 임베딩 → 한국어/중국어 디코더. 데이터 부족 시 GAN 합성 데이터 생성. few-shot learning(에트루리아어 복원 방법론). BLEU 스코어 평가. GPU 1주 훈련.

TRANSFORMER · NMT

처리 흐름 시각화

OCR → 파싱 → 번역 파이프라인

manchu_pipeline.py — 실시간 처리 데모

입력 · 만주 문자

ᠮᠠᠨᠵᡠ
ᡤᡡᡵᡠᠨ
ᡤᡳᠰᡠᠨ

            manju gurun gisun
          

→

출력 · 번역 결과

만주 나라의 말
Manchu Nation's Language

신뢰도

82%

OCR → 형태소 3개 → 번역 완료 · 0.34s

인터랙티브 사전

핵심 어휘 탐색기

어휘 선택 → 상세 정보 확인

청나라 공식 문서 용어

일상·자연 어휘

한국어 또는 로마자 검색

형태소 분석기

교착어 구조 시각화

샘플 문장 선택

어근(Root)

접미사(Suffix)

조사(Particle)

동사(Verb)

구현 코드

Python 파이프라인 스케치

manchu_ocr.py · 문자 인식 모듈

# ─── 만주어 OCR 모듈 ───────────────────────────────────────────────
import cv2
import numpy as np
import pytesseract
from pathlib import Path

class ManchuOCR:
    def __init__(self, model_path: str = "manchu_tessdata"):
        self.config = f"--oem 3 --psm 6 --tessdata-dir {model_path}"
        pytesseract.pytesseract.tesseract_cmd = "/usr/bin/tesseract"

    def preprocess(self, img_path: str) -> np.ndarray:
        """이진화 + 노이즈 제거 + 대비 강화"""
        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
        # 적응형 이진화 (고문서 조명 불균일 대응)
        binary = cv2.adaptiveThreshold(
            img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY, 11, 2
        )
        # 모폴로지 노이즈 제거
        kernel = np.ones((2, 2), np.uint8)
        cleaned = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
        return cleaned

    def extract_contours(self, img: np.ndarray) -> list:
        """만주 문자 컨투어 분석 (획순 감지)"""
        contours, _ = cv2.findContours(
            img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
        )
        # 세로쓰기 만주 문자: 위→아래 정렬
        return sorted(contours, key=lambda c: cv2.boundingRect(c)[1])

    def recognize(self, img_path: str) -> str:
        """이미지 → 만주 로마자 변환"""
        processed = self.preprocess(img_path)
        text = pytesseract.image_to_string(
            processed, lang="manchu", config=self.config
        )
        return self._postprocess(text)

    def _postprocess(self, raw: str) -> str:
        """한자 병기 패턴으로 오류 수정"""
        corrections = {
            "gvrun": "gurun",   # 나라
            "amba1": "amba",    # 크다
            "han9": "han",      # 황제
        }
        for wrong, right in corrections.items():
            raw = raw.replace(wrong, right)
        return raw.strip()

manchu_parser.py · 형태소 분석 모듈

# ─── 만주어 형태소 분석 (교착어 처리) ─────────────────────────────
import re
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class Morpheme:
    form: str
    type: str         # root | suffix | particle | verb
    meaning: str
    pos: str          # 품사

# 만주어 접사 사전 (교착어 핵심)
SUFFIXES = {
    "-mbi":   ("현재형 동사 어미", "VERB.PRES"),
    "-ha":    ("완료형", "VERB.PERF"),
    "-me":    ("연결형", "CONV"),
    "-ngge":  ("명사화", "NMLZ"),
    "-i":     ("속격 조사", "GEN"),
    "-be":    ("대격 조사", "ACC"),
    "-de":    ("여격/처격", "DAT/LOC"),
    "-ci":    ("탈격", "ABL"),
}

ROOT_DICT = {
    "gurun": ("나라, 국가", "NOUN"),
    "niyalma": ("사람", "NOUN"),
    "han": ("황제, 칸", "NOUN"),
    "amba": ("크다, 위대한", "ADJ"),
    "gisun": ("말, 언어", "NOUN"),
    "manju": ("만주", "PROPN"),
    "boo": ("집", "NOUN"),
    "alin": ("산", "NOUN"),
}

class ManchuParser:
    def tokenize(self, sentence: str) -> List[str]:
        """공백 기반 토크나이저 (만주어는 공백 구분)
        실제 구현: BPE + 어휘 사전 결합"""
        tokens = sentence.lower().split()
        return [t.strip(".,;:") for t in tokens]

    def analyze(self, token: str) -> List[Morpheme]:
        """어근 + 접사 분리 분석"""
        morphemes = []
        remaining = token

        # 어근 매칭 (최장 일치)
        matched_root = None
        for root in sorted(ROOT_DICT, key=len, reverse=True):
            if remaining.startswith(root):
                meaning, pos = ROOT_DICT[root]
                matched_root = Morpheme(root, "root", meaning, pos)
                remaining = remaining[len(root):]
                break

        if matched_root:
            morphemes.append(matched_root)

        # 접사 체인 분석
        while remaining:
            found = False
            for suf in sorted(SUFFIXES, key=len, reverse=True):
                clean_suf = suf.lstrip("-")
                if remaining.startswith(clean_suf):
                    meaning, pos = SUFFIXES[suf]
                    morphemes.append(Morpheme(clean_suf, "suffix", meaning, pos))
                    remaining = remaining[len(clean_suf):]
                    found = True
                    break
            if not found:
                morphemes.append(Morpheme(remaining, "unknown", "?", "UNK"))
                break

        return morphemes

manchu_translate.py · NMT 번역 모듈

# ─── mBART 기반 만주어 번역 파이프라인 ────────────────────────────
import torch
from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
from datasets import Dataset
from manchu_parser import ManchuParser

class ManchuTranslator:
    MODEL_ID = "facebook/mbart-large-50-many-to-many-mmt"

    def __init__(self, fine_tuned_path: str = None):
        self.tokenizer = MBart50TokenizerFast.from_pretrained(self.MODEL_ID)
        self.model = MBartForConditionalGeneration.from_pretrained(
            fine_tuned_path or self.MODEL_ID
        )
        self.parser = ManchuParser()
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model.to(self.device)

    def translate(
        self,
        manchu_text: str,
        target_lang: str = "ko_KR"  # 한국어
    ) -> dict:
        """만주어 → 현대어 번역"""
        # 1. 형태소 분석 선행 처리
        tokens = self.parser.tokenize(manchu_text)
        morpheme_analysis = {t: self.parser.analyze(t) for t in tokens}

        # 2. 인코딩 (만주어는 커스텀 src_lang 필요)
        self.tokenizer.src_lang = "manchu_romanized"  # 커스텀 등록
        inputs = self.tokenizer(manchu_text, return_tensors="pt").to(self.device)

        # 3. 생성 (beam search, length penalty)
        with torch.no_grad():
            generated = self.model.generate(
                **inputs,
                forced_bos_token_id=self.tokenizer.lang_code_to_id[target_lang],
                num_beams=5,
                length_penalty=1.2,
                max_new_tokens=128,
                early_stopping=True,
            )

        translation = self.tokenizer.batch_decode(generated, skip_special_tokens=True)[0]

        return {
            "input": manchu_text,
            "translation": translation,
            "morphemes": morpheme_analysis,
            "lang": target_lang,
        }

    def fine_tune(self, parallel_corpus: Dataset, output_dir: str):
        """병기 문헌으로 fine-tuning (HuggingFace Trainer API)"""
        from transformers import Seq2SeqTrainer, Seq2SeqTrainingArguments
        args = Seq2SeqTrainingArguments(
            output_dir=output_dir,
            num_train_epochs=10,
            per_device_train_batch_size=16,
            warmup_steps=500,
            predict_with_generate=True,
            fp16=torch.cuda.is_available(),
            save_strategy="epoch",
            evaluation_strategy="epoch",
            load_best_model_at_end=True,
        )
        trainer = Seq2SeqTrainer(
            model=self.model,
            args=args,
            train_dataset=parallel_corpus["train"],
            eval_dataset=parallel_corpus["validation"],
            tokenizer=self.tokenizer,
        )
        trainer.train()
        trainer.save_model(output_dir)
        print(f"✓ Fine-tuning 완료 → {output_dir}")

개발 로드맵

순차적 구현 계획

PHASE 1 · 주 1-2

데이터셋 구축 및 환경 설정

병기 문헌 수집(만주어-한자 10만 쌍 목표), Tesseract 커스텀 훈련 데이터 준비, 만주어 1,500자 유니코드 매핑, Python 환경 및 CUDA GPU 설정.

PHASE 2 · 주 3-4

OCR 엔진 개발

Tesseract 훈련(만주 문자 특화), 이진화·컨투어 전처리 파이프라인, 한자 병기 오류 수정 사전 구축. 목표 인식률 85%.

PHASE 3 · 주 5-6

형태소 분석기 구현

교착어 접사 사전 완성, 어근-접사 분리 알고리즘, HMM 기반 품사 태거 학습, 퉁구스어족 비교 데이터 통합.

PHASE 4 · 주 7-8

mBART Fine-tuning

GPU 학습 (A100 기준 약 72시간), BLEU 스코어 목표 25 이상, 데이터 부족 시 GAN 합성 증강. few-shot learning 적용.

PHASE 5 · 주 9-10

통합 테스트 및 배포

전체 파이프라인 통합 테스트, 실제 청나라 문헌 샘플 80% 정확도 검증, REST API 래핑, 오픈소스(MIT 라이선스) 배포.

비교 벤치마킹

유사 언어 복원 프로젝트 비교

프로젝트	언어	방법론	데이터	정확도
Perseus Project	라틴어·고대그리스어	규칙 기반 파서 + 형태소 DB	풍부 (수백만 단어)	~95%
Google 히브리어 복원	사해문서 히브리어	컨투어 OCR + 딥러닝	제한적 스캔본	~90%
하와이어 부흥 앱	하와이어	NMT + 음성합성	중간 (오디오+텍스트)	~88%
에트루리아어 AI	에트루리아어	few-shot + 비교언어학	희소 (미해독 다수)	~60%
본 프로젝트	만주어 (목표)	OCR + 형태소 + mBART NMT	병기 문헌 (희소)	목표 80%

"언어가 죽으면, 그 민족이 세상을 바라보던
고유한 창문 하나가 영원히 닫힌다."

— 언어학자 켄 헤일 (Ken Hale) / 만주족의 마지막 목소리들을 기억하며

만주어 번역기 — 잊혀진 언어로

ᠮᠠᠨᠵᡠ ᡤᡳᠰᡠᠨ

만주어 번역기

한국어 → 만주어 · AI 번역 · 소멸 위기 언어 복원 프로젝트

⚠ 만주어는 학습 데이터가 매우 희소합니다. AI가 최선을 다해 번역하지만 부정확할 수 있습니다. 학술 연구에는 전문가 검증을 권장합니다. 현재 생존 화자는 전 세계 10명 미만입니다.

🇰🇷 한국어

만주어 (Manju Gisun)

번역 결과가 여기에 표시됩니다.
만주 문자 · 로마자 · 해설 포함

잊혀진 언어를 찾는 중...

0 / 300

예시 문장

나는 사람이다

하늘이 맑다

황제의 나라

산과 강

집으로 돌아가다

전쟁이 끝났다

말을 배우다

세계사

Chinese Breaking News Script/ English Breaking News Script

안보면 손해 미스터리 소멸된 만주어 복원 빌더 프로그램 Don't Miss Out: Manchu Language Revival Builder Program That Vanishes Mysteries"

잊혀진 목소리를
되살리며 — 만주어 해독 복원 시스템 —

4단계 순차 처리 로직

OCR → 파싱 → 번역 파이프라인

핵심 어휘 탐색기

교착어 구조 시각화

Python 파이프라인 스케치

순차적 구현 계획

유사 언어 복원 프로젝트 비교