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

应避免的常见问题

• 不结合上下文进行翻译，导致用词错误
• 项目中的术语不一致
• 未正确处理占位符和变量
• 忽视文化差异（日期、货币、习语）
• 未经质量检查就信任机器翻译
• 未维护翻译记忆以保持一致性
• 忽略文本扩展问题（译文通常更长）
• 忽视从右向左书写语言的注意事项