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

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로 복원하려는
학술·문화 보존 프로젝트입니다. 오픈소스로 배포됩니다.
데이터가 부족합니다. 만주어 화자를 아신다면 연락 주세요.

GitHub 오픈소스 데이터셋 기여 논문 참고자료 화자 제보

ᠮᠠᠨᠵᡠ ᡤᡳᠰᡠᠨ

만주어 번역기

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

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

🇰🇷 한국어

만주어 (Manju Gisun)

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

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

0 / 300

예시 문장

나는 사람이다

하늘이 맑다

황제의 나라

산과 강

집으로 돌아가다

전쟁이 끝났다

말을 배우다

번역 기록

만주어 복원 프로젝트 · AI 번역 엔진 (Claude) · 오픈소스
이 번역기는 소멸 위기 언어 보존을 위해 만들어졌습니다