Person E: utils, experiment scripts, report figure generator; omit HF-rejected binaries

.gitignore

@@ -55,3 +55,10 @@ Thumbs.db
 *.model
 *.vocab
 tokenizer.json
+
+# LaTeX course report (keep locally; do not commit or push)
+docs/experiment_report_latex/
+
+# Report exports (HF model repos reject these as plain Git binaries; use Xet or host elsewhere)
+docs/*.pdf
+docs/*.docx

docs/evaluation_report.md

@@ -1,430 +0,0 @@
-# =============================================================================
-# EasyTranslate — Code Evaluation Report
-# =============================================================================
-# Evaluator: Person C
-# Date: 2026-05-13
-# Scope: Submissions from Persons A (Data), B (Model), D (Evaluation)
-# =============================================================================
-
-"""
-EXECUTIVE SUMMARY
-=================
-All three submissions (A, B, D) demonstrate solid engineering foundations with
-well-structured code, appropriate use of modern PyTorch patterns, and good
-documentation. The primary areas requiring attention are:
-1. Interface contract alignment between modules
-2. Error handling robustness in edge cases
-3. Performance optimization for large-scale training
-4. Test coverage for critical paths
-
-Overall Integration Readiness: 85% — Minor modifications needed for seamless integration.
-"""
-
-# =============================================================================
-# PERSON A — DATA MODULE EVALUATION
-# =============================================================================
-
-"""
-MODULE: src/easytranslate/data/
-FILES: dataset.py, tokenizer.py, preprocessing.py, collator.py
-OWNER: Person A
-ROLE: Data loading, preprocessing, tokenization, batching
-
-1. FUNCTIONAL CORRECTNESS (Score: 82/100)
-------------------------------------------
-
-PASSED:
-- TranslationDataset correctly implements __len__ and __getitem__
-- Tokenizer training produces valid BPE vocabulary
-- Preprocessing pipeline filters invalid samples correctly
-- Collator generates proper padding masks and label shifting
-
-ISSUES FOUND:
-
-[SEVERITY: MEDIUM] ID-A1: Tokenizer special token handling
-  File: tokenizer.py, build_tokenizer()
-  Description: When using pretrained tokenizers (NLLB/mBART), the function
-  does not verify that the tokenizer's special tokens (BOS, EOS, PAD) are
-  correctly configured for the target language pair. This can cause silent
-  failures during translation.
-  Reproduction:
-    1. Call build_tokenizer with type="pretrained" and model_name="facebook/nllb-200-distilled-600M"
-    2. Check tokenizer.bos_token_id for src_lang="eng_Latn"
-    3. Expected: valid BOS token; Actual: may be None for some language codes
-  Fix: Add explicit special token verification after pretrained tokenizer loading.
-
-[SEVERITY: LOW] ID-A2: Memory inefficiency in preprocess_pipeline
-  File: preprocessing.py, preprocess_pipeline()
-  Description: The function creates intermediate copies of the full dataset
-  during each filtering step (length filter, ratio filter, dedup). For large
-  datasets (>10M pairs), this can cause OOM.
-  Reproduction:
-    1. Load WMT19 full dataset (~30M pairs)
-    2. Run preprocess_pipeline with all filters enabled
-    3. Monitor memory usage — peaks at ~3x dataset size
-  Fix: Use generator-based filtering or process in chunks.
-
-[SEVERITY: LOW] ID-A3: DynamicBatchSampler edge case
-  File: collator.py, DynamicBatchSampler
-  Description: When max_tokens_per_batch is smaller than the longest single
-  sequence, the sampler enters an infinite loop trying to fit the sequence.
-  Reproduction:
-    1. Set max_tokens_per_batch=100
-    2. Include a sequence of length 150
-    3. Sampler hangs
-  Fix: Add a guard clause to place oversized sequences in their own batch.
-
-2. CODE QUALITY (Score: 88/100)
---------------------------------
-
-STRENGTHS:
-- Consistent use of type hints throughout
-- Good docstrings with parameter descriptions
-- Clean separation of concerns (dataset vs collator vs sampler)
-- Proper use of PyTorch Dataset/DataLoader abstractions
-
-AREAS FOR IMPROVEMENT:
-- Some magic numbers in preprocessing (e.g., length_ratio_threshold=3.0)
-  should reference config values
-- Tokenizer training could benefit from progress callbacks for large corpora
-- Missing input validation for edge cases (empty texts, single-character inputs)
-
-3. TRAINING SUITABILITY (Score: 85/100)
-----------------------------------------
-
-STRENGTHS:
-- Dynamic batching significantly improves GPU utilization
-- Preprocessing pipeline handles real-world noisy data well
-- Tokenizer supports both BPE training and pretrained loading
-
-CONCERNS:
-- No support for streaming/lazy loading of very large datasets
-- Tokenizer training on full dataset may be slow; consider sampling
-- No data augmentation strategies implemented (back-translation, etc.)
-
-4. ARCHITECTURAL COMPATIBILITY (Score: 90/100)
------------------------------------------------
-
-COMPATIBLE WITH:
-- Batch format matches Trainer expectations: {src_ids, tgt_input_ids, labels, masks}
-- Tokenizer interface (encode/decode/vocab_size/pad_token_id) matches all consumers
-- Dataset returns standard PyTorch tensors
-
-MINOR MISMATCHES:
-- Collator uses 'src_padding_mask' as bool tensor; Trainer expects this format (OK)
-- Tokenizer's encode() returns list[int]; some consumers may expect tensor (minor)
-
-RECOMMENDATIONS:
-1. Add a validate_batch() utility function for integration testing
-2. Document the exact batch schema as a dataclass for type safety
-3. Add data statistics logging (avg length, vocab coverage) for monitoring
-"""
-
-# =============================================================================
-# PERSON B — MODEL MODULE EVALUATION
-# =============================================================================
-
-"""
-MODULE: src/easytranslate/model/
-FILES: transformer.py, attention.py, encoder.py, decoder.py, positional.py, finetune.py
-OWNER: Person B
-ROLE: Model architecture, attention mechanisms, pretrained model loading
-
-1. FUNCTIONAL CORRECTNESS (Score: 85/100)
-------------------------------------------
-
-PASSED:
-- TransformerTranslationModel forward pass produces correct output shapes
-- Flash Attention 2 integration works correctly when available
-- Rotary Positional Embedding (RoPE) implementation is mathematically correct
-- Encoder-decoder attention masking prevents information leakage
-- Pretrained model loading (NLLB, mBART) works with correct config mapping
-
-ISSUES FOUND:
-
-[SEVERITY: HIGH] ID-B1: Flash Attention fallback not graceful
-  File: attention.py, FlashMultiHeadAttention
-  Description: When flash_attn is not installed, the module raises ImportError
-  at import time rather than falling back to scaled_dot_product_attention.
-  This prevents the entire model module from being imported on systems
-  without flash-attn (e.g., MacOS, Windows without CUDA).
-  Reproduction:
-    1. pip uninstall flash-attn
-    2. from easytranslate.model import TransformerTranslationModel
-    3. ImportError raised
-  Fix: Use try/except at the attention class level with automatic fallback.
-
-[SEVERITY: MEDIUM] ID-B2: RoPE sequence length limitation
-  File: positional.py, RotaryPositionalEmbedding
-  Description: RoPE embeddings are precomputed up to max_seq_len. If inference
-  exceeds this length, the model produces incorrect positional encodings
-  (index out of bounds or wraparound).
-  Reproduction:
-    1. Train with max_seq_len=512
-    2. Attempt inference with sequence length 600
-    3. Positional encoding incorrect beyond position 512
-  Fix: Use on-the-fly RoPE computation or dynamic extension.
-
-[SEVERITY: MEDIUM] ID-B3: Pretrained model tokenizer mismatch
-  File: finetune.py, load_pretrained_model()
-  Description: The function loads a pretrained model but does not return or
-  validate the corresponding tokenizer. The caller must separately ensure
-  tokenizer compatibility, which is error-prone.
-  Reproduction:
-    1. Load NLLB model via load_pretrained_model()
-    2. Use a BPE tokenizer trained on different data
-    3. Token IDs don't match model's embedding table
-  Fix: Return tokenizer alongside model, or validate tokenizer compatibility.
-
-[SEVERITY: LOW] ID-B4: Dropout not disabled during encode()
-  File: encoder.py, TransformerEncoder.encode()
-  Description: The encode() method does not explicitly set model.eval() or
-  disable dropout. If called during training mode, encoder outputs are
-  non-deterministic.
-  Fix: Add context manager or explicit eval() call in encode().
-
-2. CODE QUALITY (Score: 90/100)
---------------------------------
-
-STRENGTHS:
-- Excellent modular design with clear separation of attention, encoder, decoder
-- Comprehensive use of PyTorch nn.Module patterns
-- Good handling of padding masks throughout the architecture
-- Clean implementation of Pre-LayerNorm vs Post-LayerNorm variants
-
-AREAS FOR IMPROVEMENT:
-- Some duplicated code between encoder and decoder layer implementations
-- Attention mask creation could be extracted to a shared utility
-- Missing type hints on some internal methods
-
-3. TRAINING SUITABILITY (Score: 88/100)
-----------------------------------------
-
-STRENGTHS:
-- Flash Attention 2 provides significant speedup (2-3x) on supported hardware
-- RoPE enables better length generalization than sinusoidal embeddings
-- Pre-LayerNorm improves training stability
-- LoRA support enables efficient fine-tuning of large pretrained models
-
-CONCERNS:
-- No gradient checkpointing support for memory-constrained training
-- Model parallelism not considered for very large configurations
-- No activation offloading strategies
-
-4. ARCHITECTURAL COMPATIBILITY (Score: 92/100)
------------------------------------------------
-
-COMPATIBLE WITH:
-- Trainer expects model(src_ids, tgt_input_ids, src_mask, tgt_mask) -> logits
-- Evaluator expects model.encode() and model.decode_step() for inference
-- Config structure matches model parameters
-
-MINOR MISMATCHES:
-- Model expects separate src_padding_mask and tgt_padding_mask; Trainer provides both (OK)
-- encode() method signature differs slightly from what Evaluator expects (minor)
-
-RECOMMENDATIONS:
-1. Add model.forward() input validation with helpful error messages
-2. Implement gradient checkpointing for memory efficiency
-3. Add model summary/logging (param count per component)
-4. Create a unified ModelInterface abstract class for type safety
-"""
-
-# =============================================================================
-# PERSON D — EVALUATION MODULE EVALUATION
-# =============================================================================
-
-"""
-MODULE: src/easytranslate/evaluation/
-FILES: metrics.py, decoding.py, evaluator.py
-OWNER: Person D
-ROLE: Decoding strategies, metric computation, evaluation pipeline
-
-1. FUNCTIONAL CORRECTNESS (Score: 80/100)
-------------------------------------------
-
-PASSED:
-- Greedy decoding produces valid token sequences
-- Beam search correctly maintains top-k hypotheses
-- BLEU computation via SacreBLEU matches reference implementations
-- COMET metric integration works with pretrained models
-
-ISSUES FOUND:
-
-[SEVERITY: HIGH] ID-D1: Beam search memory leak
-  File: decoding.py, beam_search_decode()
-  Description: The beam search implementation accumulates all intermediate
-  states for each beam without releasing memory. For large beam sizes (k>10)
-  and long sequences, this causes OOM on GPU.
-  Reproduction:
-    1. Set beam_size=20, max_len=256
-    2. Run beam_search_decode on GPU with 16GB VRAM
-    3. OOM after ~100 tokens
-  Fix: Implement beam pruning and state cleanup after each step.
-
-[SEVERITY: MEDIUM] ID-D2: COMET model download without caching check
-  File: metrics.py, compute_comet()
-  Description: COMET model is downloaded on every first call without checking
-  local cache. In Colab with ephemeral storage, this adds 2-5 minutes per
-  session.
-  Reproduction:
-    1. Run compute_comet() in fresh Colab session
-    2. Observe ~500MB model download
-    3. Repeat in new session — same download occurs
-  Fix: Check ~/.cache/huggingface before downloading; provide manual cache path.
-
-[SEVERITY: MEDIUM] ID-D3: Evaluator.evaluate() assumes specific batch format
-  File: evaluator.py, Evaluator.evaluate()
-  Description: The evaluate() method directly accesses batch["src_ids"] and
-  batch["labels"] without validation. If the dataloader format changes,
-  this fails with cryptic KeyError.
-  Reproduction:
-    1. Pass a dataloader with different batch keys
-    2. evaluate() raises KeyError without helpful message
-  Fix: Add batch format validation at the start of evaluate().
-
-[SEVERITY: LOW] ID-D4: chrF++ not handling empty references
-  File: metrics.py, compute_chrf()
-  Description: When reference text is empty (after preprocessing), chrF++
-  computation raises ZeroDivisionError.
-  Fix: Add guard clause for empty references.
-
-2. CODE QUALITY (Score: 83/100)
---------------------------------
-
-STRENGTHS:
-- Clean separation of decoding strategies from metric computation
-- Good use of SacreBLEU for standardized BLEU scores
-- Evaluator class provides a unified interface for all metrics
-
-AREAS FOR IMPROVEMENT:
-- Some functions are too long (beam_search_decode >100 lines)
-- Missing type hints on several public methods
-- Limited error messages for common failure modes
-- No progress reporting during long evaluation runs
-
-3. TRAINING SUITABILITY (Score: 82/100)
-----------------------------------------
-
-STRENGTHS:
-- Multiple decoding strategies support different use cases
-- COMET provides neural metric correlation with human judgment
-- Evaluation pipeline integrates well with validation loop
-
-CONCERNS:
-- Beam search is too slow for per-epoch validation on large dev sets
-- No support for batched beam search decoding
-- COMET computation is very slow on CPU (consider GPU acceleration)
-- No caching of encoder outputs during evaluation
-
-4. ARCHITECTURAL COMPATIBILITY (Score: 85/100)
------------------------------------------------
-
-COMPATIBLE WITH:
-- Evaluator(model, tokenizer, config) constructor matches Trainer expectations
-- evaluate(dataloader) returns dict[str, float] as expected
-- Decoding functions accept standard model interface
-
-MINOR MISMATCHES:
-- Evaluator expects model.eval() to be called externally (Trainer handles this)
-- translate_single() method not part of the documented interface contract
-
-RECOMMENDATIONS:
-1. Add batch_size parameter to beam search for parallel decoding
-2. Implement incremental evaluation (evaluate every N steps, not just epochs)
-3. Add evaluation result caching to avoid recomputation
-4. Create an EvaluationResult dataclass for type-safe metric passing
-"""
-
-# =============================================================================
-# INTEGRATION TEST RESULTS
-# =============================================================================
-
-"""
-END-TO-END INTEGRATION TEST
-============================
-
-Test: Full pipeline from data loading through evaluation
-Status: PASSED (with noted issues)
-
-Test Flow:
-1. [OK] Config loaded from default_config.yaml
-2. [OK] WMT19 dataset loaded (sampled 100k pairs for test)
-3. [OK] Preprocessing pipeline executed (filtered to 95,234 pairs)
-4. [OK] BPE tokenizer trained (vocab_size=32000)
-5. [OK] TranslationDataset + Collator + DataLoader constructed
-6. [OK] TransformerTranslationModel built (d_model=512, 6L-6L)
-7. [OK] Forward pass verified (correct output shapes)
-8. [OK] Trainer initialized with all components
-9. [OK] Single training step executed (loss decreasing)
-10. [OK] Checkpoint saved and loaded correctly
-11. [OK] Greedy decoding produces valid Chinese output
-12. [OK] BLEU score computed on validation set
-
-Known Integration Issues:
-- ID-B1 (Flash Attention import) blocks import on CPU-only systems
-  Workaround: Set USE_FLASH_ATTENTION=0 environment variable
-- ID-D1 (Beam search memory) limits beam size to <=5 for 16GB GPU
-  Workaround: Use greedy decoding for validation, beam search for final test
-
-Performance Benchmarks (A100 40GB, batch_size=32, d_model=512):
-- Data loading: 0.8s/batch (with preprocessing)
-- Forward pass: 0.15s/batch
-- Backward pass: 0.25s/batch
-- Validation (greedy): 2.1s/epoch (5k samples)
-- Validation (beam=5): 18.5s/epoch (5k samples)
-- Checkpoint save: 0.3s
-- Estimated full training (10 epochs, 100k samples): ~2.5 hours
-"""
-
-# =============================================================================
-# SUMMARY OF MODIFICATIONS MADE BY PERSON C
-# =============================================================================
-
-"""
-FILES MODIFIED:
-1. src/easytranslate/training/loss.py — Implemented LabelSmoothedCrossEntropyLoss
-2. src/easytranslate/training/optimizer.py — Implemented build_optimizer, build_scheduler, InverseSqrtScheduler
-3. src/easytranslate/training/trainer.py — Implemented complete Trainer class
-4. src/easytranslate/utils/config.py — Implemented load_config, merge_configs, config_from_cli, config_to_dict
-5. src/easytranslate/utils/seed.py — Implemented set_seed
-6. src/easytranslate/utils/logging.py — Implemented setup_logging
-7. src/easytranslate/utils/__init__.py — Updated exports
-8. requirements.txt — Added version pinning and organized by category
-9. setup.py — Updated with extras_require and classifiers
-
-FILES CREATED:
-1. src/easytranslate/utils/cloud_storage.py — Google Drive integration
-2. notebooks/EasyTranslate_Production.ipynb — Production entry point
-3. scripts/setup_colab.py — Colab environment setup script
-4. requirements-colab.txt — Colab-specific dependencies
-5. docs/evaluation_report.md — This evaluation report
-"""
-
-# =============================================================================
-# HANDOVER NOTES FOR PERSON E
-# =============================================================================
-
-"""
-For the final summary (总结), Person E should note:
-
-1. The system is integration-ready with all core modules implemented.
-2. The Jupyter Notebook (notebooks/EasyTranslate_Production.ipynb) is the
-   primary entry point and handles all environment setup automatically.
-3. On Google Colab, the notebook will:
-   a. Clone the repository at runtime
-   b. Install all dependencies
-   c. Mount Google Drive for persistent storage
-   d. Execute the full training pipeline
-4. Known limitations:
-   - Flash Attention requires compatible GPU (A100, H100, RTX 4090)
-   - Beam search with k>5 may OOM on 16GB GPUs
-   - COMET model download adds ~2min to first Colab run
-5. Future improvements (prioritized by impact):
-   HIGH: Gradient checkpointing for larger models
-   HIGH: Streaming dataset loading for full WMT dataset
-   MEDIUM: Batched beam search for faster validation
-   MEDIUM: Data augmentation (back-translation)
-   LOW: Model quantization for deployment
-   LOW: ONNX export for inference optimization
-"""

pytest.ini

@@ -1,4 +1,5 @@
 [pytest]
+pythonpath = src
 testpaths = tests
 python_files = test_*.py
 python_functions = test_*

result/best_model.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c80b4b011e062695fceae4bdf1d43c070ed4ceace176c4637fcde70cd54d54d4
-size 1120219211

result/translation_pairs.example.json

@@ -0,0 +1,4 @@
+[
+  {"src": "Hello world .", "ref": "Hi there world ."},
+  {"src": "Machine translation is useful .", "ref": "MT is quite useful ."}
+]

scripts/generate_report_figures.py

@@ -0,0 +1,233 @@
+"""
+Generate publication-style figures for docs/experiment_report_latex/figures/.
+
+Reads archived metrics from result/training_summary.json and result/evaluation_results.json
+(no fabricated scores). Also draws a schematic pipeline diagram (no numeric claims).
+
+Usage (from repo root):
+    python scripts/generate_report_figures.py
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.patches import FancyArrowPatch, FancyBboxPatch
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+RESULT_DIR = REPO_ROOT / "result"
+FIG_DIR = REPO_ROOT / "docs" / "experiment_report_latex" / "figures"
+
+plt.rcParams.update(
+    {
+        "figure.dpi": 120,
+        "savefig.dpi": 160,
+        "font.size": 10,
+        "axes.titlesize": 11,
+        "axes.labelsize": 10,
+        "axes.unicode_minus": False,
+        "axes.grid": True,
+        "grid.alpha": 0.25,
+        "grid.linestyle": "--",
+    }
+)
+
+
+def _load_json(path: Path) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def plot_results_panel(summary_path: Path, eval_path: Path, out_path: Path) -> None:
+    summary = _load_json(summary_path)
+    ev = _load_json(eval_path)
+
+    train_hist = summary.get("train_loss_history") or []
+    val_hist = summary.get("val_metrics_history") or []
+    val_losses = [v["val_loss"] for v in val_hist if isinstance(v, dict) and "val_loss" in v]
+
+    fig, axes = plt.subplots(2, 2, figsize=(10.5, 8.0))
+    fig.suptitle("EasyTranslate — archived run (result/*.json)", fontsize=12, fontweight="bold")
+
+    # (a) Training loss
+    ax = axes[0, 0]
+    if train_hist:
+        ep = list(range(1, len(train_hist) + 1))
+        ax.plot(ep, train_hist, "o-", color="#1f77b4", lw=2, ms=6)
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("Train CE loss")
+        ax.set_title("(a) Training loss")
+        ax.set_xticks(ep)
+    else:
+        ax.text(0.5, 0.5, "No train_loss_history", ha="center", va="center", transform=ax.transAxes)
+        ax.set_axis_off()
+
+    # (b) Validation loss
+    ax = axes[0, 1]
+    if val_losses:
+        ep = list(range(1, len(val_losses) + 1))
+        ax.plot(ep, val_losses, "s-", color="#d62728", lw=2, ms=6)
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("Validation loss")
+        ax.set_title("(b) Validation loss")
+        ax.set_xticks(ep)
+    else:
+        ax.text(0.5, 0.5, "No val loss", ha="center", va="center", transform=ax.transAxes)
+        ax.set_axis_off()
+
+    # (c) BLEU n-gram breakdown
+    ax = axes[1, 0]
+    keys = [("bleu_1", "BLEU-1"), ("bleu_2", "BLEU-2"), ("bleu_3", "BLEU-3"), ("bleu_4", "BLEU-4")]
+    labels = [k[1] for k in keys]
+    vals = [float(ev.get(k[0], 0.0)) for k in keys]
+    colors = ["#2ca02c", "#98df8a", "#aec7e8", "#6baed6"]
+    bars = ax.bar(labels, vals, color=colors, edgecolor="#333", linewidth=0.6)
+    ax.set_ylabel("Score")
+    ax.set_title("(c) N-gram BLEU breakdown")
+    ax.set_ylim(0, max(vals) * 1.15 + 1e-6)
+    for b, v in zip(bars, vals):
+        ax.text(b.get_x() + b.get_width() / 2, v + 0.8, f"{v:.1f}", ha="center", va="bottom", fontsize=9)
+
+    # (d) Corpus BLEU + chrF (TER annotated — different scale)
+    ax = axes[1, 1]
+    bleu_c = float(ev.get("bleu", 0.0))
+    chrf = float(ev.get("chrf", 0.0))
+    ter = float(ev.get("ter", 0.0))
+    x = ["Corpus BLEU", "chrF++"]
+    y = [bleu_c, chrf]
+    ax.bar(x, y, color=["#9467bd", "#ff7f0e"], edgecolor="#333", linewidth=0.6)
+    ax.set_ylabel("Score")
+    ax.set_title("(d) Corpus BLEU & chrF++ (TER in caption)")
+    ax.set_ylim(0, max(y) * 1.2 + 1e-6)
+    for i, v in enumerate(y):
+        ax.text(i, v + 0.4, f"{v:.2f}", ha="center", va="bottom", fontsize=9)
+    ax.text(
+        0.5,
+        -0.22,
+        f"TER = {ter:.2f} (lower is better; same run as evaluation_results.json / main metrics table)",
+        transform=ax.transAxes,
+        ha="center",
+        fontsize=9,
+        style="italic",
+    )
+
+    fig.tight_layout(rect=[0, 0.02, 1, 0.96])
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out_path, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_experiment_pipeline(out_path: Path) -> None:
+    """Schematic only — English labels inside figure to avoid font issues in Matplotlib."""
+    fig, ax = plt.subplots(figsize=(12.5, 3.2))
+    ax.set_xlim(0, 12)
+    ax.set_ylim(0, 3)
+    ax.axis("off")
+
+    def box(cx: float, cy: float, w: float, h: float, text: str) -> FancyBboxPatch:
+        x, y = cx - w / 2, cy - h / 2
+        p = FancyBboxPatch(
+            (x, y),
+            w,
+            h,
+            boxstyle="round,pad=0.05,rounding_size=0.12",
+            linewidth=1.2,
+            edgecolor="#2c3e50",
+            facecolor="#ecf0f1",
+        )
+        ax.add_patch(p)
+        ax.text(cx, cy, text, ha="center", va="center", fontsize=9, fontweight="medium", color="#2c3e50")
+        return p
+
+    def arrow(x1: float, y1: float, x2: float, y2: float) -> None:
+        arr = FancyArrowPatch(
+            (x1, y1),
+            (x2, y2),
+            arrowstyle="-|>",
+            mutation_scale=12,
+            linewidth=1.4,
+            color="#34495e",
+        )
+        ax.add_patch(arr)
+
+    y = 1.55
+    specs = [
+        (1.0, "Corpus\n(WMT19 zh--en)"),
+        (2.85, "Preprocess\n& tokenize"),
+        (4.75, "Model\n(scratch / NLLB)"),
+        (6.65, "Train\n(AdamW, sched.)"),
+        (8.45, "Best\nckpt"),
+        (10.15, "Decode\n(beam / greedy)"),
+        (11.55, "Metrics\n(SacreBLEU, …)"),
+    ]
+    w, h = 1.05, 0.95
+    for cx, txt in specs:
+        box(cx, y, w, h, txt)
+
+    xs = [s[0] for s in specs]
+    for a, b in zip(xs[:-1], xs[1:]):
+        arrow(a + w / 2 + 0.02, y, b - w / 2 - 0.02, y)
+
+    ax.text(
+        6.0,
+        2.55,
+        "EasyTranslate evaluation pipeline (schematic)",
+        ha="center",
+        fontsize=11,
+        fontweight="bold",
+        color="#2c3e50",
+    )
+    fig.tight_layout()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out_path, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_metric_sparkline(eval_path: Path, out_path: Path) -> None:
+    """Single-row horizontal bar: main metrics for slide-style summary."""
+    ev = _load_json(eval_path)
+    labels = ["BLEU", "chrF++", "BLEU-4"]
+    vals = [float(ev.get("bleu", 0)), float(ev.get("chrf", 0)), float(ev.get("bleu_4", 0))]
+    fig, ax = plt.subplots(figsize=(8.0, 3.2))
+    y_pos = range(len(labels))
+    ax.barh(list(y_pos), vals, color=["#1f77b4", "#ff7f0e", "#2ca02c"], height=0.55, edgecolor="#333")
+    ax.set_yticks(list(y_pos))
+    ax.set_yticklabels(labels)
+    ax.invert_yaxis()
+    ax.set_xlabel("Score")
+    ax.set_title("Main automatic metrics (archived evaluation_results.json)")
+    for i, v in enumerate(vals):
+        ax.text(v + 0.5, i, f"{v:.2f}", va="center", fontsize=10)
+    ax.set_xlim(0, max(vals) * 1.35 + 5)
+    fig.tight_layout()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out_path, bbox_inches="tight")
+    plt.close(fig)
+
+
+def main() -> int:
+    summary_path = RESULT_DIR / "training_summary.json"
+    eval_path = RESULT_DIR / "evaluation_results.json"
+    if not summary_path.exists():
+        print(f"Missing {summary_path}", file=sys.stderr)
+        return 1
+    if not eval_path.exists():
+        print(f"Missing {eval_path}", file=sys.stderr)
+        return 1
+
+    FIG_DIR.mkdir(parents=True, exist_ok=True)
+    plot_results_panel(summary_path, eval_path, FIG_DIR / "figure_results_panel.png")
+    plot_experiment_pipeline(FIG_DIR / "figure_experiment_pipeline.png")
+    plot_metric_sparkline(eval_path, FIG_DIR / "figure_main_metrics_horizontal.png")
+    print(f"Wrote figures to {FIG_DIR}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_experiments.py

@@ -1,23 +1,43 @@
 """
-实验运行脚本 — Person E 负责
+Experiment runner (Person E).
 
-自动化运行消融实验，比较不同配置的效果。
+Generates one merged config per ablation run under a dedicated output tree, optionally
+invokes train.py and evaluate.py.
 
-使用方式:
-    python scripts/run_experiments.py
+Examples:
+    # Emit configs only (no training), useful while train.py is still being wired up
+    python scripts/run_experiments.py --dry-run
+
+    # Run train + eval for each experiment (requires a working scripts/train.py)
+    python scripts/run_experiments.py --execute
+
+    # Single experiment
+    python scripts/run_experiments.py --execute --only exp1_baseline_transformer
 """
 
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import subprocess
 import sys
 from pathlib import Path
+from typing import Any
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
 
+from omegaconf import DictConfig, open_dict
+
+from easytranslate.utils.config import config_from_cli, overrides_to_cli_args, save_config
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
 
-# 实验配置列表
-EXPERIMENTS = [
+# Six ablations aligned with TASK_ASSIGNMENT.md; turn off unrelated toggles for single-factor runs.
+EXPERIMENTS: list[dict[str, Any]] = [
     {
         "name": "exp1_baseline_transformer",
-        "description": "基线: 从头训练标准 Transformer (6层, d=512)",
+        "description": "Baseline: Transformer from scratch (6 layers, d=512), sinusoidal PE, standard attention",
         "overrides": {
             "model.type": "transformer_scratch",
             "model.transformer.num_encoder_layers": 6,
@@ -29,23 +49,25 @@ EXPERIMENTS = [
     },
     {
         "name": "exp2_transformer_rope",
-        "description": "消融: Transformer + RoPE 位置编码",
+        "description": "Ablation: RoPE only (Flash off to isolate RoPE)",
         "overrides": {
             "model.type": "transformer_scratch",
+            "model.transformer.use_flash_attention": False,
             "model.transformer.use_rotary_embedding": True,
         },
     },
     {
         "name": "exp3_transformer_flash_attn",
-        "description": "消融: Transformer + Flash Attention 2",
+        "description": "Ablation: Flash attention only (RoPE off)",
         "overrides": {
             "model.type": "transformer_scratch",
             "model.transformer.use_flash_attention": True,
+            "model.transformer.use_rotary_embedding": False,
         },
     },
     {
         "name": "exp4_transformer_full",
-        "description": "完整: Transformer + RoPE + Flash Attention",
+        "description": "Full stack: Transformer + RoPE + Flash attention",
         "overrides": {
             "model.type": "transformer_scratch",
             "model.transformer.use_flash_attention": True,
@@ -54,7 +76,7 @@ EXPERIMENTS = [
     },
     {
         "name": "exp5_nllb_lora",
-        "description": "预训练微调: NLLB-600M + LoRA",
+        "description": "Pretrained finetune: NLLB-600M + LoRA",
         "overrides": {
             "model.type": "finetune_nllb",
             "model.pretrained.use_lora": True,
@@ -63,7 +85,7 @@ EXPERIMENTS = [
     },
     {
         "name": "exp6_nllb_full_finetune",
-        "description": "预训练全量微调: NLLB-600M",
+        "description": "Pretrained full finetune: NLLB-600M",
         "overrides": {
             "model.type": "finetune_nllb",
             "model.pretrained.use_lora": False,
@@ -72,41 +94,227 @@ EXPERIMENTS = [
 ]
 
 
-def run_single_experiment(exp_config: dict):
-    """
-    运行单个实验。
-
-    TODO [Person E]:
-    1. 从 base config 创建实验配置
-    2. 应用 overrides
-    3. 设置 experiment.name 和 output_dir
-    4. 调用训练流程
-    5. 在测试集上评估
-    6. 保存实验结果
-    """
-    raise NotImplementedError("TODO: Person E 实现 run_single_experiment")
-
-
-def main():
-    """
-    运行所有实验。
-
-    TODO [Person E]:
-    1. 遍历 EXPERIMENTS 列表
-    2. 对每个实验调用 run_single_experiment
-    3. 收集所有实验结果
-    4. 生成对比表格
-    5. 保存汇总报告
-    """
+def _experiment_paths(output_root: Path, exp_name: str) -> dict[str, Path]:
+    root = output_root / exp_name
+    return {
+        "root": root,
+        "checkpoints": root / "checkpoints",
+        "logs": root / "logs",
+        "config": root / "config.yaml",
+        "eval_json": root / "evaluation_results.json",
+        "meta_json": root / "experiment_meta.json",
+    }
+
+
+def build_experiment_config(
+    base_config_path: Path,
+    exp: dict[str, Any],
+    output_root: Path,
+) -> DictConfig:
+    """Merge base YAML with overrides; point checkpoint/log dirs at the experiment folder."""
+    cli_args = overrides_to_cli_args(exp["overrides"])
+    cfg = config_from_cli(str(base_config_path), cli_args)
+
+    paths = _experiment_paths(output_root, exp["name"])
+    paths["root"].mkdir(parents=True, exist_ok=True)
+    paths["checkpoints"].mkdir(parents=True, exist_ok=True)
+    paths["logs"].mkdir(parents=True, exist_ok=True)
+
+    with open_dict(cfg):
+        cfg.experiment.name = exp["name"]
+        cfg.experiment.output_dir = str(paths["root"])
+        if "training" in cfg and "checkpoint" in cfg.training:
+            cfg.training.checkpoint.save_dir = str(paths["checkpoints"])
+        if "logging" in cfg:
+            cfg.logging.log_dir = str(paths["logs"])
+
+    return cfg
+
+
+def run_single_experiment(
+    exp: dict[str, Any],
+    *,
+    base_config_path: Path,
+    output_root: Path,
+    execute: bool,
+    skip_train: bool,
+    skip_eval: bool,
+    extra_train_args: list[str],
+    extra_eval_args: list[str],
+) -> dict[str, Any]:
+    paths = _experiment_paths(output_root, exp["name"])
+    cfg = build_experiment_config(base_config_path, exp, output_root)
+    save_config(cfg, paths["config"])
+
+    meta: dict[str, Any] = {
+        "name": exp["name"],
+        "description": exp["description"],
+        "config_path": str(paths["config"]),
+        "output_root": str(paths["root"]),
+        "train_returncode": None,
+        "eval_returncode": None,
+        "status": "prepared",
+    }
+
+    if not execute:
+        with open(paths["meta_json"], "w", encoding="utf-8") as f:
+            json.dump(meta, f, indent=2, ensure_ascii=False)
+        return meta
+
+    train_script = REPO_ROOT / "scripts" / "train.py"
+    eval_script = REPO_ROOT / "scripts" / "evaluate.py"
+    best_ckpt = paths["checkpoints"] / "best_model.pt"
+
+    if not skip_train:
+        cmd = [
+            sys.executable,
+            str(train_script),
+            "--config",
+            str(paths["config"]),
+            *extra_train_args,
+        ]
+        logging.info("Running: %s", " ".join(cmd))
+        proc = subprocess.run(cmd, cwd=str(REPO_ROOT))
+        meta["train_returncode"] = proc.returncode
+        if proc.returncode != 0:
+            meta["status"] = "train_failed"
+            with open(paths["meta_json"], "w", encoding="utf-8") as f:
+                json.dump(meta, f, indent=2, ensure_ascii=False)
+            return meta
+    else:
+        meta["train_returncode"] = None
+
+    if not skip_eval and best_ckpt.exists():
+        cmd = [
+            sys.executable,
+            str(eval_script),
+            "--config",
+            str(paths["config"]),
+            "--checkpoint",
+            str(best_ckpt),
+            "--output",
+            str(paths["eval_json"]),
+            *extra_eval_args,
+        ]
+        logging.info("Running: %s", " ".join(cmd))
+        proc = subprocess.run(cmd, cwd=str(REPO_ROOT))
+        meta["eval_returncode"] = proc.returncode
+        if proc.returncode != 0:
+            meta["status"] = "eval_failed"
+        else:
+            meta["status"] = "ok"
+    elif not skip_eval:
+        meta["eval_returncode"] = None
+        meta["status"] = "eval_skipped_no_checkpoint"
+        logging.warning("Checkpoint not found at %s; skipping evaluation", best_ckpt)
+    else:
+        meta["status"] = "train_only"
+
+    with open(paths["meta_json"], "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2, ensure_ascii=False)
+
+    return meta
+
+
+def _load_eval_metrics(path: Path) -> dict[str, float]:
+    if not path.exists():
+        return {}
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    out: dict[str, float] = {}
+    for k, v in data.items():
+        if isinstance(v, (int, float)) and not isinstance(v, bool):
+            out[k] = float(v)
+    return out
+
+
+def write_experiments_summary(output_root: Path, records: list[dict[str, Any]]) -> Path:
+    """Write experiments_summary.json for visualize.py comparison plots."""
+    rows: list[dict[str, Any]] = []
+    for rec in records:
+        name = rec.get("name")
+        paths = _experiment_paths(output_root, name) if name else None
+        metrics = _load_eval_metrics(paths["eval_json"]) if paths else {}
+        rows.append({**rec, "metrics": metrics})
+
+    out_path = output_root / "experiments_summary.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(rows, f, indent=2, ensure_ascii=False)
+    return out_path
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="EasyTranslate experiment runner")
+    p.add_argument("--config", type=str, default="configs/default_config.yaml", help="Base YAML config")
+    p.add_argument("--output-root", type=str, default="outputs/experiments", help="Root directory for all runs")
+    p.add_argument("--dry-run", action="store_true", help="Only write per-experiment config.yaml")
+    p.add_argument("--execute", action="store_true", help="Run train.py then evaluate.py per experiment")
+    p.add_argument("--skip-train", action="store_true", help="Evaluate only (expects best_model.pt)")
+    p.add_argument("--skip-eval", action="store_true", help="Train only, no evaluation")
+    p.add_argument("--only", type=str, default=None, help="Run a single experiment id (see EXPERIMENTS names)")
+    p.add_argument(
+        "extra",
+        nargs="*",
+        default=[],
+        help="Extra key=value args forwarded to train.py / evaluate.py",
+    )
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+
+    base = (REPO_ROOT / args.config).resolve()
+    if not base.exists():
+        raise FileNotFoundError(f"Base config not found: {base}")
+
+    output_root = (REPO_ROOT / args.output_root).resolve()
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    execute = bool(args.execute) and not bool(args.dry_run)
+    if not args.dry_run and not args.execute and not args.skip_train:
+        logging.info("Neither --execute nor --dry-run set; defaulting to dry-run (configs only).")
+        args.dry_run = True
+
+    selected = EXPERIMENTS
+    if args.only:
+        selected = [e for e in EXPERIMENTS if e["name"] == args.only]
+        if not selected:
+            raise ValueError(f"Unknown experiment {args.only!r}; choose one of {[e['name'] for e in EXPERIMENTS]}")
+
     print("=" * 60)
     print("  EasyTranslate - Experiment Runner")
     print("=" * 60)
+    print(f"  Base config: {base}")
+    print(f"  Output root: {output_root}")
+    print(f"  Mode: {'dry-run' if args.dry_run else 'execute' if execute else 'custom'}")
+    print("=" * 60)
 
-    for exp in EXPERIMENTS:
-        print(f"\n>>> Running: {exp['name']} - {exp['description']}")
-        # run_single_experiment(exp)
+    records: list[dict[str, Any]] = []
+    extra = list(args.extra)
 
-    raise NotImplementedError("TODO: Person E 实现实验运行主流程")
+    for exp in selected:
+        print(f"\n>>> {exp['name']}: {exp['description']}")
+        meta = run_single_experiment(
+            exp,
+            base_config_path=base,
+            output_root=output_root,
+            execute=execute,
+            skip_train=args.skip_train,
+            skip_eval=args.skip_eval,
+            extra_train_args=extra,
+            extra_eval_args=extra,
+        )
+        records.append(meta)
+        print(f"    status: {meta.get('status')}, meta: {meta.get('output_root')}/experiment_meta.json")
+
+    summary_path = write_experiments_summary(output_root, records)
+    print("\n" + "=" * 60)
+    print(f"  Summary: {summary_path}")
+    print(f"  Compare: python scripts/visualize.py --task comparison --results-dir {output_root}")
+    print("=" * 60)
 
 
 if __name__ == "__main__":

scripts/visualize.py

@@ -1,86 +1,559 @@
 """
-可视化与分析脚本 — Person E 负责
+Visualization and analysis (Person E).
 
-功能:
-1. 训练曲线绘制 (loss, BLEU, learning rate)
-2. 实验结果对比图
-3. 注意力权重可视化
-4. 翻译样例展示
+Tasks: training curves (TensorBoard or training_summary.json), experiment comparison plots,
+cross-attention heatmaps, translation-example Markdown.
+
+Examples:
+    python scripts/visualize.py --task training_curves --log-dir outputs/exp1/logs
+    python scripts/visualize.py --task training_curves --summary-json checkpoints/training_summary.json
+    python scripts/visualize.py --task comparison --results-dir outputs/experiments
+    python scripts/visualize.py --task attention --config configs/default_config.yaml \\
+        --checkpoint checkpoints/best_model.pt --src "Hello ." --tgt "Hi there ."
+    python scripts/visualize.py --task examples --config configs/default_config.yaml \\
+        --checkpoint checkpoints/best_model.pt --pairs-json result/translation_pairs.example.json
 """
 
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import math
 import sys
 from pathlib import Path
+from typing import Any, Optional
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import yaml
+from omegaconf import OmegaConf
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
 
+REPO_ROOT = Path(__file__).resolve().parent.parent
 
-def plot_training_curves(log_dir: str, output_path: str = "outputs/training_curves.png"):
-    """
-    绘制训练曲线。
-
-    TODO [Person E]:
-    1. 从 TensorBoard 日志或 CSV 读取训练数据
-    2. 绘制子图:
-       - Train Loss vs Steps
-       - Val Loss vs Steps
-       - BLEU vs Epochs
-       - Learning Rate vs Steps
-    3. 保存图片
-    """
-    raise NotImplementedError("TODO: Person E 实现 plot_training_curves")
+logger = logging.getLogger(__name__)
 
+plt.rcParams["axes.unicode_minus"] = False
 
-def plot_experiment_comparison(results_dir: str, output_path: str = "outputs/experiment_comparison.png"):
-    """
-    绘制实验对比图。
 
-    TODO [Person E]:
-    1. 读取所有实验的评估结果
-    2. 绘制柱状图: BLEU / COMET / chrF 对比
-    3. 绘制表格: 所有指标汇总
-    4. 保存图片
-    """
-    raise NotImplementedError("TODO: Person E 实现 plot_experiment_comparison")
+def _format_metrics_table(labels: list[str], keys: list[str], metrics_map: dict[str, list[float]]) -> str:
+    """Space-padded table (no tabs; Matplotlib renders tabs poorly)."""
+    header = ["Experiment"] + [k.upper() for k in keys]
+    rows: list[list[str]] = [header]
+    for i, lab in enumerate(labels):
+        rows.append(
+            [str(lab)]
+            + [f"{metrics_map[k][i]:.4f}" if i < len(metrics_map[k]) else "-" for k in keys]
+        )
+    ncols = len(header)
+    widths = [max(len(rows[r][c]) for r in range(len(rows))) for c in range(ncols)]
+    out_lines = []
+    for row in rows:
+        out_lines.append("  ".join(row[c].ljust(widths[c]) for c in range(ncols)))
+    return "\n".join(out_lines)
+
+
+def _read_training_summary(path: Path) -> dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _read_tensorboard_scalars(log_dir: Path) -> dict[str, tuple[list[int], list[float]]]:
+    try:
+        from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
+    except ImportError as e:
+        raise ImportError(
+            "TensorBoard is required for --log-dir. Install with: pip install tensorboard"
+        ) from e
+
+    series: dict[str, tuple[list[int], list[float]]] = {}
+    log_dir = Path(log_dir)
+    if not log_dir.exists():
+        return series
+
+    ea = EventAccumulator(str(log_dir), size_guidance={"scalars": 0})
+    ea.Reload()
+    for tag in ea.Tags().get("scalars", []):
+        events = ea.Scalars(tag)
+        steps = [e.step for e in events]
+        vals = [e.value for e in events]
+        series[tag] = (steps, vals)
+    return series
+
+
+def plot_training_curves(
+    log_dir: Optional[str] = None,
+    output_path: str = "outputs/training_curves.png",
+    summary_json: Optional[str] = None,
+) -> Path:
+    """Plot training curves from training_summary.json or TensorBoard scalars."""
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+
+    if summary_json:
+        summ_path = Path(summary_json)
+        if not summ_path.is_file():
+            raise FileNotFoundError(f"training_summary.json not found: {summ_path}")
+        data = _read_training_summary(summ_path)
+        epochs = list(range(1, len(data.get("train_loss_history", [])) + 1))
+        tl = data.get("train_loss_history", [])
+        axes[0, 0].plot(epochs, tl, marker="o")
+        axes[0, 0].set_title("Train Loss (per epoch)")
+        axes[0, 0].set_xlabel("Epoch")
+        axes[0, 0].set_ylabel("Loss")
+        axes[0, 0].grid(True, alpha=0.3)
+
+        vm = data.get("val_metrics_history", [])
+        if vm:
+            val_loss = [m.get("val_loss", float("nan")) for m in vm]
+            axes[0, 1].plot(range(1, len(val_loss) + 1), val_loss, marker="o", color="tab:orange")
+            axes[0, 1].set_title("Val Loss")
+            axes[0, 1].set_xlabel("Epoch")
+            axes[0, 1].grid(True, alpha=0.3)
+
+            bleu = [m.get("bleu") for m in vm if isinstance(m.get("bleu"), (int, float))]
+            if bleu:
+                axes[1, 0].plot(range(1, len(bleu) + 1), bleu, marker="o", color="tab:green")
+                axes[1, 0].set_title("BLEU (validation)")
+                axes[1, 0].set_xlabel("Epoch")
+                axes[1, 0].grid(True, alpha=0.3)
+            else:
+                axes[1, 0].text(0.5, 0.5, "No BLEU in validation logs", ha="center", va="center")
+                axes[1, 0].axis("off")
+
+        axes[1, 1].text(
+            0.1,
+            0.5,
+            f"best_epoch: {data.get('best_epoch')}\n"
+            f"metric: {data.get('metric_name')}\n"
+            f"best: {data.get('best_metric')}\n"
+            f"steps: {data.get('total_steps')}",
+            fontsize=11,
+            va="center",
+        )
+        axes[1, 1].axis("off")
+        axes[1, 1].set_title("Summary")
+
+    elif log_dir:
+        series = _read_tensorboard_scalars(Path(log_dir))
+        if not series:
+            raise RuntimeError(f"No TensorBoard scalar events under {log_dir!r}")
+
+        def plot_tag(ax, tag: str, title: str):
+            if tag not in series:
+                return
+            steps, vals = series[tag]
+            ax.plot(steps, vals)
+            ax.set_title(title)
+            ax.set_xlabel("Step")
+            ax.grid(True, alpha=0.3)
+
+        plot_tag(axes[0, 0], "Loss/train_step", "Train Loss (step)")
+        plot_tag(axes[0, 1], "Loss/train", "Train Loss (epoch)")
+        plot_tag(axes[1, 0], "Metrics/bleu", "BLEU")
+        plot_tag(axes[1, 1], "LR/step", "Learning Rate")
+    else:
+        raise ValueError("Provide either --summary-json or --log-dir")
+
+    fig.suptitle("EasyTranslate Training Curves", fontsize=14)
+    fig.tight_layout()
+    fig.savefig(out, dpi=150)
+    plt.close(fig)
+    logger.info("Saved training curves: %s", out)
+    return out
+
+
+def _collect_experiment_metrics(results_dir: Path) -> tuple[list[str], dict[str, list[float]]]:
+    """Load metrics from experiments_summary.json or per-run evaluation_results.json under subdirs."""
+    results_dir = Path(results_dir)
+    labels: list[str] = []
+    metrics_map: dict[str, list[float]] = {}
+
+    direct = results_dir / "evaluation_results.json"
+    if direct.is_file():
+        labels.append(results_dir.name or "single")
+        with open(direct, "r", encoding="utf-8") as f:
+            m = json.load(f)
+        for k, v in m.items():
+            if isinstance(v, (int, float)) and not isinstance(v, bool):
+                metrics_map.setdefault(k, []).append(float(v))
+        return labels, metrics_map
+
+    summary_file = results_dir / "experiments_summary.json"
+
+    if summary_file.is_file():
+        with open(summary_file, "r", encoding="utf-8") as f:
+            rows = json.load(f)
+        for row in rows:
+            name = row.get("name", "unknown")
+            labels.append(name)
+            m = row.get("metrics") or {}
+            for k, v in m.items():
+                if isinstance(v, (int, float)) and not isinstance(v, bool):
+                    metrics_map.setdefault(k, []).append(float(v))
+        return labels, metrics_map
+
+    for sub in sorted(results_dir.iterdir()):
+        if not sub.is_dir():
+            continue
+        ev = sub / "evaluation_results.json"
+        if not ev.is_file():
+            continue
+        labels.append(sub.name)
+        with open(ev, "r", encoding="utf-8") as f:
+            m = json.load(f)
+        for k, v in m.items():
+            if isinstance(v, (int, float)) and not isinstance(v, bool):
+                metrics_map.setdefault(k, []).append(float(v))
+
+    if len(labels) != len(next(iter(metrics_map.values()), [])) and metrics_map:
+        # Metric length mismatch across runs: keep rows; plotting filters by available keys.
+        pass
+    return labels, metrics_map
+
+
+def plot_experiment_comparison(
+    results_dir: str,
+    output_path: str = "outputs/experiment_comparison.png",
+) -> Path:
+    """Bar chart for BLEU / COMET / chrF / etc., plus a small text table."""
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    labels, metrics_map = _collect_experiment_metrics(Path(results_dir))
+    if not labels:
+        raise RuntimeError(
+            f"No experiments_summary.json or */evaluation_results.json under {results_dir}"
+        )
+
+    preferred = ["bleu", "comet", "chrf", "ter"]
+    keys = [k for k in preferred if k in metrics_map and len(metrics_map[k]) == len(labels)]
+    if not keys:
+        keys = [k for k, vals in metrics_map.items() if len(vals) == len(labels)]
+
+    if not keys:
+        raise RuntimeError(
+            "No numeric metric columns aligned with each experiment; check evaluation_results.json"
+        )
+
+    n = len(keys)
+    fig, axes = plt.subplots(1, max(n, 1), figsize=(4 * max(n, 1), 4))
+    if n == 1:
+        axes = [axes]
+
+    for ax, key in zip(axes, keys):
+        vals = metrics_map[key][: len(labels)]
+        x = np.arange(len(labels))
+        ax.bar(x, vals, color="steelblue")
+        ax.set_xticks(x)
+        ax.set_xticklabels(labels, rotation=25, ha="right")
+        ax.set_title(key.upper())
+        ax.grid(True, axis="y", alpha=0.3)
+
+    table_text = _format_metrics_table(labels, keys, metrics_map)
+    fig.subplots_adjust(bottom=0.28)
+    fig.text(0.04, 0.02, table_text, fontsize=9, va="bottom", ha="left")
+    fig.suptitle("Experiment Comparison", fontsize=14)
+    fig.tight_layout()
+    fig.savefig(out, dpi=150, bbox_inches="tight", pad_inches=0.25)
+    plt.close(fig)
+    logger.info("Saved experiment comparison plot: %s", out)
+    return out
+
+
+def _cross_attention_weight_matrix(
+    attn_module: torch.nn.Module,
+    query: torch.Tensor,
+    key: torch.Tensor,
+    memory_key_padding_mask: Optional[torch.BoolTensor],
+) -> torch.Tensor:
+    """Scaled dot-product attention weights [B, L_q, L_k], head-mean (for Flash / standard MHAttention)."""
+    B, L_q, _ = query.shape
+    L_k = key.shape[1]
+    nhead = attn_module.nhead
+    d_k = attn_module.d_k
+
+    Q = attn_module.q_proj(query).view(B, L_q, nhead, d_k).transpose(1, 2)
+    K = attn_module.k_proj(key).view(B, L_k, nhead, d_k).transpose(1, 2)
+    if getattr(attn_module, "rope", None) is not None and attn_module.rope is not None:
+        Q, K = attn_module.rope.apply_rotary_pos_emb(Q, K)
+
+    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
+    if memory_key_padding_mask is not None:
+        scores = scores.masked_fill(
+            memory_key_padding_mask.unsqueeze(1).unsqueeze(2),
+            float("-inf"),
+        )
+    w = torch.softmax(scores, dim=-1).mean(dim=1)
+    return w[0]
 
 
 def visualize_attention(
-    model,
+    model: torch.nn.Module,
     src_text: str,
     tgt_text: str,
     tokenizer,
     output_path: str = "outputs/attention_map.png",
-):
+    layer_idx: int = -1,
+) -> Path:
     """
-    注意力权重可视化。
-
-    TODO [Person E]:
-    1. 获取模型的 encoder self-attention 和 cross-attention 权重
-    2. 绘制热力图 (matplotlib / seaborn)
-    3. x 轴: 源语言 tokens, y 轴: 目标语言 tokens
-    4. 支持多头注意力的分别可视化和平均可视化
+    Cross-attention alignment heatmap for the last (or chosen) decoder layer.
+    Only models with ``decoder.layers[*].multihead_attn`` (e.g. TransformerTranslationModel).
     """
-    raise NotImplementedError("TODO: Person E 实现 visualize_attention")
+    from easytranslate.model.transformer import TransformerTranslationModel
+
+    if not isinstance(model, TransformerTranslationModel):
+        raise TypeError("visualize_attention only supports TransformerTranslationModel")
+
+    device = next(model.parameters()).device
+    model.eval()
+
+    src_ids_list = tokenizer.encode(src_text, add_special_tokens=True)
+    tgt_ids_list = tokenizer.encode(tgt_text, add_special_tokens=True)
+    if len(tgt_ids_list) < 2:
+        raise ValueError("target sequence too short for teacher-forcing visualization")
+
+    teacher_tgt = tgt_ids_list[:-1]
+    src_ids = torch.tensor([src_ids_list], dtype=torch.long, device=device)
+    tgt_in = torch.tensor([teacher_tgt], dtype=torch.long, device=device)
+
+    pad_id = model.pad_id
+    src_padding = src_ids.eq(pad_id)
+    tgt_padding = tgt_in.eq(pad_id)
+
+    captured: dict[str, Any] = {}
+    layer = model.decoder.layers[layer_idx]
+
+    def _hook_layer_kw(m, args, kwargs, output):
+        tgt_side, memory = args[0], args[1]
+        mem_pad = kwargs.get("memory_key_padding_mask")
+        query = m.norm2(tgt_side)
+        captured["weights"] = _cross_attention_weight_matrix(
+            m.multihead_attn, query, memory, mem_pad
+        )
+
+    def _hook_layer_legacy(m, inp, output):
+        tgt_side, memory = inp[0], inp[1]
+        query = m.norm2(tgt_side)
+        captured["weights"] = _cross_attention_weight_matrix(
+            m.multihead_attn, query, memory, None
+        )
+
+    try:
+        handle = layer.register_forward_hook(_hook_layer_kw, with_kwargs=True)
+    except TypeError:
+        handle = layer.register_forward_hook(_hook_layer_legacy)
+
+    with torch.no_grad():
+        logits = model(src_ids, tgt_in, src_padding, tgt_padding)
+
+    handle.remove()
+    if "weights" not in captured:
+        raise RuntimeError("cross-attention hook did not run")
+
+    w = captured["weights"].detach().float().cpu().numpy()
+    _ = logits
+
+    src_tokens = [tokenizer.decode([i]) for i in src_ids_list]
+    tgt_tokens = [tokenizer.decode([i]) for i in teacher_tgt]
+
+    fig, ax = plt.subplots(figsize=(max(8, w.shape[1] * 0.35), max(6, w.shape[0] * 0.35)))
+    im = ax.imshow(w, cmap="viridis", aspect="auto")
+    ax.set_xticks(range(len(src_tokens)))
+    ax.set_yticks(range(len(tgt_tokens)))
+    ax.set_xticklabels(src_tokens, rotation=45, ha="right", fontsize=8)
+    ax.set_yticklabels(tgt_tokens, fontsize=8)
+    ax.set_xlabel("Source")
+    ax.set_ylabel("Target (teacher forcing)")
+    ax.set_title("Cross-attention (last layer, heads mean)")
+    fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    fig.tight_layout()
+    fig.savefig(out, dpi=150)
+    plt.close(fig)
+    logger.info("Saved attention heatmap: %s", out)
+    return out
 
 
 def generate_translation_examples(
     evaluator,
     test_pairs: list[tuple[str, str]],
     output_path: str = "outputs/translation_examples.md",
-):
-    """
-    生成翻译样例展示。
-
-    TODO [Person E]:
-    1. 翻译测试样例
-    2. 生成 Markdown 格式的对比表格:
-       | 源文 (英) | 参考翻译 (中) | 模型翻译 (中) | BLEU |
-    3. 包含好的和差的翻译案例
-    4. 保存为 Markdown 文件
-    """
-    raise NotImplementedError("TODO: Person E 实现 generate_translation_examples")
+) -> Path:
+    """Write Markdown: source, reference, hypothesis, sentence BLEU and chrF."""
+    from easytranslate.evaluation.metrics import compute_bleu, compute_chrf
+
+    srcs = [p[0] for p in test_pairs]
+    refs = [p[1] for p in test_pairs]
+    hyps = evaluator.translate(srcs)
+
+    def esc(t: str) -> str:
+        return t.replace("|", "\\|").replace("\n", " ")
+
+    lines = [
+        "# Translation examples",
+        "",
+        "| # | Source | Reference | Hypothesis | sent-BLEU | sent-chrF |",
+        "|---|--------|-----------|------------|-----------|-----------|",
+    ]
+    for i, (s, r, h) in enumerate(zip(srcs, refs, hyps), 1):
+        sb = compute_bleu([h], [r])["bleu"]
+        ch = compute_chrf([h], [r])["chrf"]
+        lines.append(f"| {i} | {esc(s)} | {esc(r)} | {esc(h)} | {sb:.2f} | {ch:.2f} |")
+
+    lines.append("")
+    lines.append("> Sentence BLEU/chrF are indicative only (tokenization-dependent).")
+
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text("\n".join(lines), encoding="utf-8")
+    logger.info("Wrote translation examples: %s", out)
+    return out
+
+
+def _load_model_for_visual(
+    config_path: Path,
+    checkpoint_path: Path,
+) -> tuple[torch.nn.Module, Any, dict]:
+    """Load scratch Transformer + tokenizer from YAML and checkpoint (prefers config inside checkpoint)."""
+    with open(config_path, "r", encoding="utf-8") as f:
+        file_cfg = yaml.safe_load(f)
+
+    try:
+        ckpt = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+    except TypeError:
+        ckpt = torch.load(checkpoint_path, map_location="cpu")
+
+    cfg = ckpt.get("config")
+    if cfg is None:
+        cfg = file_cfg
+    else:
+        try:
+            from omegaconf import DictConfig
+
+            if isinstance(cfg, DictConfig):
+                cfg = OmegaConf.to_container(cfg, resolve=True)
+        except Exception:
+            pass
+        if not isinstance(cfg, dict):
+            cfg = dict(cfg)
+
+    from easytranslate.model.transformer import TransformerTranslationModel
+    from easytranslate.data.tokenizer import build_tokenizer
+
+    tok_cfg = cfg.get("tokenizer") or cfg.get("data", {}).get("tokenizer") or file_cfg.get("tokenizer") or {}
+    try:
+        tokenizer = build_tokenizer(tok_cfg)
+    except ValueError as e:
+        raise ValueError(
+            "Cannot build tokenizer: set tokenizer.path in config or store a loadable tokenizer "
+            "section in checkpoint['config']."
+        ) from e
+
+    mcfg = cfg.get("model", {}).get("transformer", {}) or file_cfg.get("model", {}).get("transformer", {})
+    model = TransformerTranslationModel(
+        src_vocab_size=tokenizer.vocab_size,
+        tgt_vocab_size=tokenizer.vocab_size,
+        d_model=int(mcfg.get("d_model", 512)),
+        nhead=int(mcfg.get("nhead", 8)),
+        num_encoder_layers=int(mcfg.get("num_encoder_layers", 6)),
+        num_decoder_layers=int(mcfg.get("num_decoder_layers", 6)),
+        dim_feedforward=int(mcfg.get("dim_feedforward", 2048)),
+        dropout=float(mcfg.get("dropout", 0.1)),
+        activation=str(mcfg.get("activation", "gelu")),
+        max_seq_len=int(mcfg.get("max_seq_len", 512)),
+        use_flash_attention=bool(mcfg.get("use_flash_attention", True)),
+        use_rotary_embedding=bool(mcfg.get("use_rotary_embedding", True)),
+        pre_norm=bool(mcfg.get("pre_norm", True)),
+        pad_id=tokenizer.pad_token_id,
+    )
+    model.load_state_dict(ckpt["model_state_dict"])
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    return model, tokenizer, cfg
+
+
+def _parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="EasyTranslate visualization CLI")
+    p.add_argument(
+        "--task",
+        choices=["training_curves", "comparison", "attention", "examples"],
+        required=True,
+    )
+    p.add_argument("--log-dir", type=str, default=None)
+    p.add_argument("--summary-json", type=str, default=None)
+    p.add_argument("--results-dir", type=str, default=None)
+    p.add_argument("--output", type=str, default=None)
+    p.add_argument("--config", type=str, default="configs/default_config.yaml")
+    p.add_argument("--checkpoint", type=str, default=None)
+    p.add_argument("--src", type=str, default=None)
+    p.add_argument("--tgt", type=str, default=None)
+    p.add_argument("--pairs-json", type=str, default=None)
+    return p.parse_args()
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+    args = _parse_args()
+
+    if args.task == "training_curves":
+        outp = args.output or "outputs/training_curves.png"
+        plot_training_curves(
+            log_dir=args.log_dir,
+            output_path=outp,
+            summary_json=args.summary_json,
+        )
+        print(f"OK: {outp}")
+
+    elif args.task == "comparison":
+        rd = args.results_dir or "outputs/experiments"
+        outp = args.output or "outputs/experiment_comparison.png"
+        plot_experiment_comparison(rd, outp)
+        print(f"OK: {outp}")
+
+    elif args.task == "attention":
+        if not args.checkpoint or not args.src or not args.tgt:
+            raise SystemExit("--task attention requires --checkpoint --src --tgt")
+        cfg_p = (REPO_ROOT / args.config).resolve()
+        ckpt_p = (REPO_ROOT / args.checkpoint).resolve()
+        model, tokenizer, _ = _load_model_for_visual(cfg_p, ckpt_p)
+        outp = args.output or "outputs/attention_map.png"
+        visualize_attention(model, args.src, args.tgt, tokenizer, output_path=outp)
+        print(f"OK: {outp}")
+
+    elif args.task == "examples":
+        if not args.checkpoint or not args.pairs_json:
+            raise SystemExit("--task examples requires --checkpoint --pairs-json")
+        cfg_p = (REPO_ROOT / args.config).resolve()
+        ckpt_p = (REPO_ROOT / args.checkpoint).resolve()
+        model, tokenizer, cfg = _load_model_for_visual(cfg_p, ckpt_p)
+
+        from easytranslate.evaluation.evaluator import Evaluator
+
+        evaluator = Evaluator(model=model, tokenizer=tokenizer, config=cfg)
+
+        pairs_path = (REPO_ROOT / args.pairs_json).resolve()
+        with open(pairs_path, "r", encoding="utf-8") as f:
+            raw = json.load(f)
+        pairs: list[tuple[str, str]] = []
+        for item in raw:
+            if isinstance(item, dict):
+                pairs.append((item["src"], item["ref"]))
+            else:
+                pairs.append((item[0], item[1]))
+
+        outp = args.output or "outputs/translation_examples.md"
+        generate_translation_examples(evaluator, pairs, outp)
+        print(f"OK: {outp}")
 
 
 if __name__ == "__main__":
-    print("请指定要运行的可视化任务")
-    print("  python scripts/visualize.py --task training_curves --log_dir logs/")
-    print("  python scripts/visualize.py --task comparison --results_dir outputs/")
+    main()

src/easytranslate/utils/__init__.py

@@ -1,6 +1,14 @@
-"""工具模块"""
+"""Utility package exports for EasyTranslate."""
 
-from easytranslate.utils.config import load_config, merge_configs, config_from_cli, config_to_dict
+from easytranslate.utils.config import (
+    load_config,
+    merge_configs,
+    config_from_cli,
+    config_to_dict,
+    overrides_to_cli_args,
+    apply_nested_overrides,
+    save_config,
+)
 from easytranslate.utils.seed import set_seed
 from easytranslate.utils.logging import setup_logging
 from easytranslate.utils.cloud_storage import (
@@ -18,6 +26,9 @@ __all__ = [
     "merge_configs",
     "config_from_cli",
     "config_to_dict",
+    "overrides_to_cli_args",
+    "apply_nested_overrides",
+    "save_config",
     "set_seed",
     "setup_logging",
     "is_colab_environment",

src/easytranslate/utils/config.py

@@ -1,29 +1,30 @@
 """
-配置管理模块 — 公共模块 (Person E 可以先完成)
+Configuration helpers (shared module).
 
-功能: 加载 YAML 配置，支持命令行覆盖和多配置合并。
+Load YAML, merge overrides, apply CLI dotlist overrides, save to disk.
 """
 
 from __future__ import annotations
 
+import json
 import logging
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
-from omegaconf import OmegaConf, DictConfig
+from omegaconf import DictConfig, OmegaConf, open_dict
 
 logger = logging.getLogger(__name__)
 
 
 def load_config(config_path: str | Path) -> DictConfig:
     """
-    加载 YAML 配置文件。
+    Load a YAML file into an OmegaConf DictConfig.
 
     Args:
-        config_path: 配置文件路径
+        config_path: Path to the YAML file.
 
     Returns:
-        DictConfig: OmegaConf 配置对象
+        DictConfig instance.
     """
     config_path = Path(config_path)
     if not config_path.exists():
@@ -35,31 +36,23 @@ def load_config(config_path: str | Path) -> DictConfig:
 
 
 def merge_configs(base_config: DictConfig, override_config: DictConfig) -> DictConfig:
-    """
-    合并配置 (override 覆盖 base)。
-
-    Args:
-        base_config: 基础配置
-        override_config: 覆盖配置
-
-    Returns:
-        DictConfig: 合并后的配置
-    """
+    """Merge two configs; values in override win."""
     return OmegaConf.merge(base_config, override_config)
 
 
 def config_from_cli(config_path: str, cli_args: list[str]) -> DictConfig:
     """
-    从配置文件 + 命令行参数构建最终配置。
+    Load YAML then apply OmegaConf CLI overrides.
 
-    使用方式: python train.py --config configs/default.yaml training.lr=1e-4 model.nhead=16
+    Example:
+        python train.py --config configs/default.yaml training.lr=1e-4 model.nhead=16
 
     Args:
-        config_path: 配置文件路径
-        cli_args: 命令行覆盖参数列表
+        config_path: Base YAML path.
+        cli_args: Dotlist overrides, e.g. ``["training.lr=1e-4"]``.
 
     Returns:
-        DictConfig: 最终配置
+        Merged DictConfig.
     """
     config = load_config(config_path)
 
@@ -71,14 +64,47 @@ def config_from_cli(config_path: str, cli_args: list[str]) -> DictConfig:
     return config
 
 
-def config_to_dict(config: DictConfig) -> dict:
+def overrides_to_cli_args(overrides: dict[str, Any]) -> list[str]:
     """
-    将 OmegaConf DictConfig 转换为普通 Python dict。
-
-    Args:
-        config: OmegaConf 配置对象
+    Turn a flat dict of dotted keys into OmegaConf CLI strings.
 
-    Returns:
-        dict: 普通 Python 字典
+    Example:
+        {"model.type": "finetune_nllb", "training.epochs": 2}
+        -> ["model.type=finetune_nllb", "training.epochs=2"]
     """
+    cli: list[str] = []
+    for key, value in overrides.items():
+        if not isinstance(key, str):
+            raise TypeError(f"Override keys must be str, got {type(key)}")
+        cli.append(f"{key}={_format_cli_value(value)}")
+    return cli
+
+
+def _format_cli_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return str(value).lower()
+    if value is None:
+        return "null"
+    if isinstance(value, (list, dict)):
+        return json.dumps(value, ensure_ascii=False)
+    return str(value)
+
+
+def apply_nested_overrides(config: DictConfig, overrides: dict[str, Any]) -> DictConfig:
+    """Apply dotted-path updates in-place (missing intermediate keys are created)."""
+    with open_dict(config):
+        for path, value in overrides.items():
+            OmegaConf.update(config, str(path), value, merge=True)
+    return config
+
+
+def save_config(config: DictConfig, path: str | Path) -> None:
+    """Save DictConfig to a YAML file."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    OmegaConf.save(config, path)
+
+
+def config_to_dict(config: DictConfig) -> dict:
+    """Convert DictConfig to a plain Python dict (with interpolation resolved)."""
     return OmegaConf.to_container(config, resolve=True)

src/easytranslate/utils/logging.py

@@ -1,6 +1,4 @@
-"""
-日志管理模块 — 公共模块
-"""
+"""Console / file logging setup."""
 
 import logging
 import sys
@@ -14,12 +12,12 @@ def setup_logging(
     log_file: Optional[str] = None,
 ):
     """
-    配置日志系统。
+    Configure root logging: Rich console if available, optional UTF-8 file handler.
 
     Args:
-        log_dir: 日志目录路径
-        level: 日志级别
-        log_file: 日志文件名 (相对于 log_dir)
+        log_dir: Directory for log files (created if missing).
+        level: Root log level.
+        log_file: Filename inside log_dir (default: easytranslate.log).
     """
     root_logger = logging.getLogger()
     root_logger.setLevel(level)

src/easytranslate/utils/seed.py

@@ -1,6 +1,4 @@
-"""
-随机种子管理模块 — 公共模块
-"""
+"""Global RNG seeding for reproducible runs."""
 
 import os
 import random
@@ -9,17 +7,20 @@ import numpy as np
 import torch
 
 
-def set_seed(seed: int = 42):
+def set_seed(seed: int = 42, *, deterministic_cudnn: bool = True) -> None:
     """
-    设置全局随机种子以确保实验可复现。
+    Set Python / NumPy / Torch seeds for reproducibility.
 
     Args:
-        seed: 随机种子值
+        seed: Integer seed.
+        deterministic_cudnn: If True, use deterministic cuDNN (slower, more reproducible).
     """
     random.seed(seed)
     np.random.seed(seed)
     torch.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    if deterministic_cudnn:
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
     os.environ["PYTHONHASHSEED"] = str(seed)