Translation Assistant

翻訳アシスタント

翻訳アシスタントスキルは、言語の壁を正確かつ文化的に適切な方法で橋渡しする、多言語翻訳システムの実装を支援します。簡単なフレーズの翻訳から文書全体のローカライズまで、幅広い翻訳ニーズを扱います。

ニューラル機械翻訳や大規模言語モデルによって現代の翻訳は大きく変わりましたが、効果的な翻訳には依然として、文脈、専門分野、文化的なニュアンスの理解が必要です。このスキルは、適切なツールの選択、翻訳品質の管理、複数の言語に対応するシステムの構築を支援します。

ユーザーインターフェース、顧客とのコミュニケーション、技術文書、クリエイティブコンテンツのいずれを翻訳する場合でも、このスキルを使えば、正確で自然かつ文化的に適切な翻訳を実現できます。

主なワークフロー

ワークフロー 1：翻訳方法を選ぶ

1. 要件を評価します：
   • 必要な言語ペア
   • 分野の専門性
   • 品質要件
   • 翻訳量と速度の要件
   • 予算の制約
2. 選択肢を比較します：

   方法	品質	速度	コスト	最適な用途
   Google Translate API	良好	高速	$	一般用途、大量翻訳
   DeepL	非常に良好	高速	$$	欧州言語、品質重視
   OpenAI/Anthropic	優秀	中速	$$$	ニュアンス重視、文脈が重要な翻訳
   カスタム NMT	分野特化	高速	導入コスト	専門分野
   人間による翻訳 + MT	最高	低速	$$$$	重要なコンテンツ

3. トレードオフを踏まえて選択します
4. 品質保証プロセスを計画します

ワークフロー 2：翻訳パイプラインを実装する

1. 翻訳サービスを設定します：

   from google.cloud import translate_v2 as translate
   
   class TranslationPipeline:
       def __init__(self, provider="google"):
           if provider == "google":
               self.client = translate.Client()
           elif provider == "deepl":
               self.client = deepl.Translator(auth_key)
           elif provider == "llm":
               self.client = LLMTranslator()
   
       def translate(self, text, source_lang, target_lang):
           # Preprocess
           prepared = self.preprocess(text, source_lang)
   
           # Translate
           if self.provider == "google":
               result = self.client.translate(
                   prepared,
                   source_language=source_lang,
                   target_language=target_lang
               )
               translated = result["translatedText"]
           elif self.provider == "llm":
               translated = self.llm_translate(prepared, source_lang, target_lang)
   
           # Postprocess
           final = self.postprocess(translated, target_lang)
   
           return final
   

2. 特殊なコンテンツを処理します：
   • プレースホルダーと変数を保持する
   • HTML／マークアップを処理する
   • 書式を維持する
3. 翻訳品質を検証します
4. 繰り返し使われるコンテンツにキャッシュを追加します

ワークフロー 3：ローカライズシステムを構築する

1. 翻訳対象のコンテンツを抽出します：

   def extract_strings(source_files):
       """Extract strings needing translation."""
       strings = []
       for file in source_files:
           # Find translatable strings
           content = read_file(file)
           matches = find_translatable(content)
   
           for match in matches:
               strings.append({
                   "key": generate_key(match),
                   "source": match.text,
                   "context": match.surrounding_context,
                   "file": file,
                   "line": match.line
               })
   
       return strings
   

2. 文脈を踏まえて翻訳します：

   def translate_with_context(strings, target_lang):
       results = []
       for s in strings:
           translation = translate(
               text=s["source"],
               context=s["context"],
               target_lang=target_lang
           )
           results.append({
               **s,
               "translation": translation,
               "target_lang": target_lang
           })
       return results
   

3. 翻訳管理システムに保存します：
   • 一貫性を保つための翻訳メモリ
   • 用語を管理するための用語集
   • 変更を管理するためのバージョン管理
4. ローカライズしたコンテンツをデプロイします

クイックリファレンス

アクション	コマンド／トリガー
テキストを翻訳する	「[text]を[language]に翻訳」
サービスを選ぶ	「[use case]に最適な翻訳サービス」
分野固有の用語を扱う	「[domain]の翻訳用語集」
品質を確認する	「翻訳品質を確認」
アプリをローカライズする	「[languages]向けに UI をローカライズ」
一括翻訳する	「[N]件の文書を翻訳」

ベストプラクティス

• 文脈を伝える：翻訳品質は文脈によって左右されます

  • 前後のテキストを含めます
  • 分野やテーマを指定します
  • トーンと文体（フォーマル／カジュアル）を伝えます

• 用語の一貫性を保つ：重要な用語は一貫した訳語にします

  • 分野ごとの用語集を作成します
  • 翻訳メモリを使います
  • 関係者と用語を確認します

• 書式と変数を保持する：技術コンテンツには特別な配慮が必要です

  • プレースホルダー（{name}、%s など）を保護します
  • HTML／Markdown の構造を維持します
  • 数値と日付の形式を適切に扱います

• 翻訳しないコンテンツを扱う：翻訳すべきでないものもあります

  • ブランド名と商標
  • 技術識別子とコード
  • 法的免責事項（場合によっては）

• 品質保証は不可欠です：機械翻訳には誤りがあります

  • 検証のために逆翻訳を行います
  • ネイティブスピーカーにレビューしてもらいます
  • 自動品質チェックを実施します

• 文化的な適応を考慮する：翻訳とローカライズは異なります

  • 日付と数値の形式
  • 通貨と単位
  • 文化的な言及と慣用句
  • 右から左へ記述する言語

高度なテクニック

LLM による文脈を考慮した翻訳

ニュアンスを反映した翻訳に言語モデルを使用します：

def llm_translate(text, source_lang, target_lang, context=None, style=None):
    prompt = f"""Translate the following text from {source_lang} to {target_lang}.

{"Context: " + context if context else ""}
{"Style: " + style if style else ""}

Important guidelines:
- Maintain the meaning and tone of the original
- Use natural, fluent {target_lang}
- Preserve any formatting, placeholders, or special characters
- If there are cultural references, adapt them appropriately

Source text:
{text}

Translation:"""

    return llm.complete(prompt)

# Example with context
result = llm_translate(
    text="The app crashed when I clicked submit.",
    source_lang="English",
    target_lang="Japanese",
    context="This is a bug report from a user",
    style="Formal technical support"
)

翻訳メモリシステム

過去の翻訳を再利用して一貫性を保ちます：

class TranslationMemory:
    def __init__(self):
        self.memory = {}  # source -> {lang: translation}
        self.fuzzy_index = FuzzyMatcher()

    def add(self, source, target_lang, translation):
        if source not in self.memory:
            self.memory[source] = {}
        self.memory[source][target_lang] = translation
        self.fuzzy_index.add(source)

    def lookup(self, source, target_lang, fuzzy_threshold=0.8):
        # Exact match
        if source in self.memory and target_lang in self.memory[source]:
            return {
                "match_type": "exact",
                "translation": self.memory[source][target_lang],
                "confidence": 1.0
            }

        # Fuzzy match
        matches = self.fuzzy_index.search(source, threshold=fuzzy_threshold)
        if matches:
            best = matches[0]
            if target_lang in self.memory[best.text]:
                return {
                    "match_type": "fuzzy",
                    "original_source": best.text,
                    "translation": self.memory[best.text][target_lang],
                    "confidence": best.score
                }

        return None

    def translate_with_memory(self, text, target_lang):
        # Check memory first
        cached = self.lookup(text, target_lang)
        if cached and cached["confidence"] > 0.95:
            return cached["translation"]

        # Translate fresh
        translation = translate_api(text, target_lang)

        # Store in memory
        self.add(text, target_lang, translation)

        return translation

分野別用語集の管理

用語の一貫性を確保します：

class TranslationGlossary:
    def __init__(self, domain):
        self.domain = domain
        self.terms = {}  # source_term -> {lang: translated_term}

    def add_term(self, source, translations):
        self.terms[source.lower()] = translations

    def apply_to_translation(self, source_text, target_lang, translation):
        """
        Ensure glossary terms are used correctly in translation.
        """
        corrections = []
        source_lower = source_text.lower()

        for term, translations in self.terms.items():
            if term in source_lower and target_lang in translations:
                expected = translations[target_lang]
                if expected.lower() not in translation.lower():
                    corrections.append({
                        "source_term": term,
                        "expected": expected,
                        "found": False
                    })

        if corrections:
            # Re-translate with glossary enforcement
            return self.translate_with_glossary(source_text, target_lang)

        return translation

    def translate_with_glossary(self, text, target_lang):
        glossary_context = "\n".join([
            f"'{term}' should be translated as '{trans[target_lang]}'"
            for term, trans in self.terms.items()
            if target_lang in trans
        ])

        prompt = f"""Translate to {target_lang}, using these required terms:
{glossary_context}

Text: {text}"""

        return llm.complete(prompt)

品質の評価

翻訳品質を自動的に評価します。

def estimate_translation_quality(source, translation, source_lang, target_lang):
    """
    Estimate translation quality without reference translation.
    """
    checks = []

    # Check 1: Back-translation similarity
    back_translated = translate(translation, target_lang, source_lang)
    back_similarity = compute_similarity(source, back_translated)
    checks.append({
        "check": "back_translation",
        "score": back_similarity,
        "details": {"back_translated": back_translated}
    })

    # Check 2: Length ratio (translations should be similar length)
    length_ratio = len(translation) / max(len(source), 1)
    expected_ratio = get_expected_length_ratio(source_lang, target_lang)
    length_score = 1 - abs(length_ratio - expected_ratio) / expected_ratio
    checks.append({
        "check": "length_ratio",
        "score": max(0, length_score),
        "details": {"ratio": length_ratio, "expected": expected_ratio}
    })

    # Check 3: LLM quality assessment
    quality_prompt = f"""Rate this translation from 1-10 for accuracy and fluency.

Source ({source_lang}): {source}
Translation ({target_lang}): {translation}

Provide scores and brief explanation."""

    llm_assessment = llm.complete(quality_prompt)
    checks.append({
        "check": "llm_assessment",
        "score": parse_score(llm_assessment) / 10,
        "details": {"assessment": llm_assessment}
    })

    # Combined score
    overall = sum(c["score"] for c in checks) / len(checks)

    return {
        "overall_score": overall,
        "checks": checks,
        "recommendation": "accept" if overall > 0.8 else "review"
    }

一貫性を保った一括翻訳

一貫性を保ちながら、大量のテキストを翻訳します。

async def batch_translate_consistent(texts, target_lang, batch_size=50):
    """
    Translate many texts while maintaining terminology consistency.
    """
    # Step 1: Extract unique terms for glossary
    all_text = " ".join(texts)
    key_terms = extract_key_terms(all_text)

    # Step 2: Translate key terms first for consistency
    term_translations = {}
    for term in key_terms:
        translation = await translate_with_verification(term, target_lang)
        term_translations[term] = translation

    # Step 3: Batch translate with glossary context
    results = []
    for batch in chunk(texts, batch_size):
        batch_results = await asyncio.gather(*[
            translate_with_glossary(text, target_lang, term_translations)
            for text in batch
        ])
        results.extend(batch_results)

    return results

よくある注意点

• 文脈を考慮せずに翻訳し、誤った語句を選んでしまう
• プロジェクト全体で用語の一貫性が保たれていない
• プレースホルダーや変数を正しく扱わない
• 文化の違い（日付、通貨、慣用句）を考慮しない
• 品質を確認せずに機械翻訳を信頼する
• 一貫性を保つための翻訳メモリを維持しない
• テキストの長さが増えることを考慮しない（翻訳後は長くなることがよくあります）
• 右から左に書く言語への配慮を怠る