Skip to content

Tibetan Translator Comparison

Jump to bottom
TenzinGayche edited this page Dec 17, 2025 · 1 revision

Tibetan Translator: V1 vs V2 Comparison

This page documents the key differences between tibetan_translator (v1) and tibetan_translator_v2.

📊 Summary Table

Aspect tibetan_translator (v1) tibetan_translator_v2
Input Processing 3 Commentary Translators UCCA + Word-by-Word + Summary
Input Source Raw Tibetan commentaries Pre-processed semantic data
Philosophy Commentary-driven translation Semantic-analysis-driven translation
Dependencies Standalone Depends on ucca_generator, word_by_word_generator
Extra Files Has llm_provider.py Missing llm_provider.py
Best Use Case Traditional scholarly texts with commentaries Detailed linguistic analysis needed

🔄 Workflow Differences

V1: Commentary-Based Workflow

                    ┌─────────────────────────────┐
                    │           START             │
                    └─────────────┬───────────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
              ▼                   ▼                   ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│ commentary_         │ │ commentary_         │ │ commentary_         │
│ translator_1        │ │ translator_2        │ │ translator_3        │
│                     │ │                     │ │                     │
│ Translates          │ │ Translates          │ │ Translates          │
│ Commentary 1        │ │ Commentary 2        │ │ Commentary 3        │
└─────────┬───────────┘ └─────────┬───────────┘ └─────────┬───────────┘
          │                       │                       │
          └───────────────────────┼───────────────────────┘
                                  │
                                  ▼
                    ┌─────────────────────────────┐
                    │         aggregator          │
                    │                             │
                    │ Combines translated         │
                    │ commentaries using LLM      │
                    └─────────────┬───────────────┘
                                  │
                                  ▼
                         (continues to translation)

V2: Semantic-Analysis Workflow

                    ┌─────────────────────────────┐
                    │           START             │
                    └─────────────┬───────────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
              ▼                   ▼                   ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│    process_ucca     │ │ process_word_by_    │ │ process_multilevel_ │
│                     │ │       word          │ │      summary        │
│ Loads UCCA graph    │ │                     │ │                     │
│ analysis from state │ │ Loads word-by-word  │ │ Loads multi-level   │
│                     │ │ translation         │ │ summary             │
└─────────┬───────────┘ └─────────┬───────────┘ └─────────┬───────────┘
          │                       │                       │
          └───────────────────────┼───────────────────────┘
                                  │
                                  ▼
                    ┌─────────────────────────────┐
                    │         aggregator          │
                    │                             │
                    │ Combines UCCA + word-by-    │
                    │ word + summary using LLM    │
                    └─────────────┬───────────────┘
                                  │
                                  ▼
                         (continues to translation)

📦 Input Processing Functions

V1: Commentary Translators

# From tibetan_translator/processors/commentary.py

def commentary_translator_1(state: State):
    """Translate first commentary with expertise focus."""
    if not state['commentary1']:
        return {"commentary1": None, "commentary1_translation": None}
    
    prompt = get_commentary_translation_prompt(
        state['sanskrit'], 
        state['source'], 
        state['commentary1'],
        language=state.get('language', 'English')
    )
    return {"commentary1": state['commentary1'], 
            "commentary1_translation": state['commentary1']}

def commentary_translator_2(state: State):
    """Translate second commentary with philosophical focus."""
    # Similar structure...

def commentary_translator_3(state: State):
    """Translate third commentary with traditional focus."""
    # Similar structure...

V2: Semantic Data Loaders

# From tibetan_translator_v2/processors/commentary.py

def process_ucca(state: State):
    """Loads the UCCA data into the state for the aggregator."""
    return {"ucca": state.get("ucca", "")}

def process_word_by_word(state: State):
    """Loads the word-by-word translation into the state for the aggregator."""
    return {"word_by_word": state.get("word_by_word", "")}

def process_multilevel_summary(state: State):
    """Loads the multi-level summary into the state for the aggregator."""
    return {"multilevel_summary": state.get("multilevel_summary", "")}

🔗 Aggregator Differences

V1 Aggregator: Combines Commentaries

def aggregator(state: State):
    """Combine commentaries based on availability."""
    
    # Check which commentaries exist
    has_commentary1 = state.get('commentary1_translation') not in [None, "", "None"]
    has_commentary2 = state.get('commentary2_translation') not in [None, "", "None"]
    has_commentary3 = state.get('commentary3_translation') not in [None, "", "None"]
    
    commentary_count = sum([has_commentary1, has_commentary2, has_commentary3])
    
    # If no commentaries, create source analysis
    if commentary_count == 0:
        source_analysis = create_source_analysis(state['source'], ...)
        return {"combined_commentary": source_analysis, "commentary_source": "source_analysis"}
    
    # If one commentary, use it directly
    if commentary_count == 1:
        if has_commentary1:
            return {"combined_commentary": state['commentary1_translation']}
        # ...
    
    # If multiple, combine them
    combined = ""
    if has_commentary1:
        combined += f"Commentary 1:\n{state['commentary1_translation']}\n\n"
    if has_commentary2:
        combined += f"Commentary 2:\n{state['commentary2_translation']}\n\n"
    if has_commentary3:
        combined += f"Commentary 3:\n{state['commentary3_translation']}\n\n"
    
    # Use LLM to create unified commentary
    prompt_messages = get_combined_commentary_prompt(...)
    response = llm_thinking.invoke(prompt_messages)
    
    return {"combined_commentary": commentary_content}

V2 Aggregator: Combines Semantic Analysis

def aggregator(state: State):
    """Combine UCCA, word-by-word, and summary into a new commentary."""
    
    # Combine the new inputs into a single string
    combined_inputs = (
        f"UCCA Analysis:\n{state.get('ucca', 'Not available.')}\n\n"
        f"Word-by-Word Translation:\n{state.get('word_by_word', 'Not available.')}\n\n"
        f"Multi-Level Summary:\n{state.get('multilevel_summary', 'Not available.')}\n\n"
    )
    
    # Use LLM to create combined commentary from semantic analysis
    prompt_messages = get_combined_commentary_prompt(
        source_text=state['source'], 
        commentaries=combined_inputs,
        has_commentaries=True,
        language=state.get('language', 'English')
    )
    
    response = llm_thinking.invoke(prompt_messages)
    
    return {"combined_commentary": commentary_content}

📋 State Fields Differences

V1 State (Commentary-focused)

class State(TypedDict):
    translation: List[str]
    commentary1_translation: str     # ✅ Used in workflow
    commentary2_translation: str     # ✅ Used in workflow
    commentary3_translation: str     # ✅ Used in workflow
    source: str
    sanskrit: str
    language: str
    feedback_history: List[str]
    format_feedback_history: List[str]
    commentary1: str                 # ✅ Input commentary
    commentary2: str                 # ✅ Input commentary
    commentary3: str                 # ✅ Input commentary
    combined_commentary: str
    commentary_source: str           # "traditional" or "source_analysis"
    key_points: List[KeyPoint]
    plaintext_translation: str  
    itteration: int
    format_iteration: int
    formated: bool
    glossary: List[GlossaryEntry]

V2 State (Semantic-analysis-focused)

class State(TypedDict):
    translation: List[str]
    commentary1_translation: str     # Present but not used in workflow
    commentary2_translation: str     # Present but not used in workflow
    commentary3_translation: str     # Present but not used in workflow
    source: str
    sanskrit: str
    language: str
    feedback_history: List[str]
    format_feedback_history: List[str]
    commentary1: str                 # Present but not used in workflow
    commentary2: str                 # Present but not used in workflow
    commentary3: str                 # Present but not used in workflow
    combined_commentary: str
    key_points: List[KeyPoint]
    plaintext_translation: str  
    itteration: int
    format_iteration: int
    formated: bool
    glossary: List[GlossaryEntry]
    # V2 Additional Fields:
    ucca: str                        # ✅ NEW: UCCA graph analysis
    word_by_word: str                # ✅ NEW: Word-by-word translation
    multilevel_summary: str          # ✅ NEW: Multi-level summary

🔧 Workflow.py Comparison

V1 Workflow Nodes

# tibetan_translator/workflow.py

optimizer_builder.add_node("commentary_translator_1", commentary_translator_1)
optimizer_builder.add_node("commentary_translator_2", commentary_translator_2)
optimizer_builder.add_node("commentary_translator_3", commentary_translator_3)
optimizer_builder.add_node("aggregator", aggregator)
optimizer_builder.add_node("translation_generator", translation_generator)
optimizer_builder.add_node("llm_call_evaluator", llm_call_evaluator)
optimizer_builder.add_node("generate_glossary", generate_glossary)

# Edges
optimizer_builder.add_edge(START, "commentary_translator_1")
optimizer_builder.add_edge(START, "commentary_translator_2")
optimizer_builder.add_edge(START, "commentary_translator_3")
optimizer_builder.add_edge("commentary_translator_1", "aggregator")
optimizer_builder.add_edge("commentary_translator_2", "aggregator")
optimizer_builder.add_edge("commentary_translator_3", "aggregator")

V2 Workflow Nodes

# tibetan_translator_v2/workflow.py

optimizer_builder.add_node("process_ucca", process_ucca)
optimizer_builder.add_node("process_word_by_word", process_word_by_word)
optimizer_builder.add_node("process_multilevel_summary", process_multilevel_summary)
optimizer_builder.add_node("aggregator", aggregator)
optimizer_builder.add_node("translation_generator", translation_generator)
optimizer_builder.add_node("llm_call_evaluator", llm_call_evaluator)
optimizer_builder.add_node("generate_glossary", generate_glossary)

# Edges
optimizer_builder.add_edge(START, "process_ucca")
optimizer_builder.add_edge(START, "process_word_by_word")
optimizer_builder.add_edge(START, "process_multilevel_summary")
optimizer_builder.add_edge("process_ucca", "aggregator")
optimizer_builder.add_edge("process_word_by_word", "aggregator")
optimizer_builder.add_edge("process_multilevel_summary", "aggregator")

🎯 When to Use Which Version

Use V1 (tibetan_translator) When:

  • ✅ You have traditional scholarly commentaries
  • ✅ Working with texts that have established commentary traditions
  • ✅ Need a standalone translation pipeline
  • ✅ Commentary interpretation is critical to translation accuracy
  • ✅ Quick setup without pre-processing requirements

Use V2 (tibetan_translator_v2) When:

  • ✅ You have pre-generated UCCA semantic graphs
  • ✅ Word-by-word translations are available
  • ✅ Multi-level summaries have been prepared
  • ✅ Need fine-grained semantic analysis
  • ✅ Working with texts that lack traditional commentaries
  • ✅ Building a full semantic pipeline with ucca_generator

📈 Data Flow Comparison

V1 Data Flow

Raw Tibetan Text + 3 Commentaries
              │
              ▼
    [Translate each commentary]
              │
              ▼
    [Combine into unified commentary]
              │
              ▼
    [Generate translation using commentary]
              │
              ▼
    [Evaluate and refine]
              │
              ▼
    Final Translation + Glossary

V2 Data Flow

Raw Tibetan Text + UCCA + Word-by-Word + Summary
              │
              ▼
    [Load pre-processed semantic data]
              │
              ▼
    [Combine into unified analysis]
              │
              ▼
    [Generate translation using semantic analysis]
              │
              ▼
    [Evaluate and refine]
              │
              ▼
    Final Translation + Glossary

🔗 Related Pages

Clone this wiki locally