[Person D] Implement evaluation module and inference scripts

## Summary

Implement the evaluation and inference module (Person D's assignment):

### Evaluation metrics (`src/easytranslate/evaluation/metrics.py`)
- SacreBLEU with Chinese tokenization
- COMET neural evaluation metric
- chrF++ and TER metrics

### Decoding strategies (`src/easytranslate/evaluation/decoding.py`)
- Greedy decoding
- Beam search with length penalty
- Sampling with temperature, top-k, and top-p

### Evaluator (`src/easytranslate/evaluation/evaluator.py`)
- Unified evaluation interface
- Batch evaluation support

### Scripts
- `scripts/evaluate.py`: Evaluation entry point
- `scripts/translate.py`: CLI interactive translation + file translation

scripts/evaluate.py

@@ -1,50 +1,285 @@
-"""
-评估入口脚本
-
-使用方式:
-    # 在测试集上评估
-    python scripts/evaluate.py --config configs/default_config.yaml --checkpoint checkpoints/best_model.pt
-
-    # 指定解码策略
-    python scripts/evaluate.py --checkpoint checkpoints/best_model.pt evaluation.decoding.strategy=beam_search evaluation.decoding.beam_size=10
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="EasyTranslate Evaluation")
-    parser.add_argument("--config", type=str, default="configs/default_config.yaml")
-    parser.add_argument("--checkpoint", type=str, required=True, help="模型检查点路径")
-    parser.add_argument("--output", type=str, default="outputs/evaluation_results.json", help="结果保存路径")
-    args, unknown = parser.parse_known_args()
-    return args, unknown
-
-
-def main():
-    """
-    评估主流程。
-
-    TODO [Person D]:
-    1. 加载配置和检查点
-    2. 重建模型并加载权重
-    3. 加载测试数据
-    4. 构建 Evaluator
-    5. 运行评估
-    6. 打印和保存结果
-    """
-    args, cli_overrides = parse_args()
-
-    print("=" * 60)
-    print("  EasyTranslate - Evaluation")
-    print("=" * 60)
-
-    raise NotImplementedError("TODO: Person D 实现评估主流程")
-
-
-if __name__ == "__main__":
-    main()
+"""
+评估入口脚本
+
+使用方式:
+    # 在测试集上评估
+    python scripts/evaluate.py --config configs/default_config.yaml --checkpoint checkpoints/best_model.pt
+
+    # 指定解码策略
+    python scripts/evaluate.py --checkpoint checkpoints/best_model.pt evaluation.decoding.strategy=beam_search evaluation.decoding.beam_size=10
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+try:
+    from omegaconf import OmegaConf
+except ImportError:  # pragma: no cover
+    OmegaConf = None
+    import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+import torch
+from torch.utils.data import DataLoader
+
+from easytranslate.data.collator import TranslationCollator
+from easytranslate.data.dataset import (
+    TranslationDataset,
+    load_custom_dataset,
+    load_opus_dataset,
+    load_wmt_dataset,
+)
+from easytranslate.data.tokenizer import TokenizerWrapper, build_tokenizer
+from easytranslate.evaluation.evaluator import Evaluator
+from easytranslate.model import TransformerTranslationModel
+from easytranslate.model.finetune import load_pretrained_model
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="EasyTranslate Evaluation")
+    parser.add_argument("--config", type=str, default="configs/default_config.yaml")
+    parser.add_argument("--checkpoint", type=str, required=True, help="模型检查点路径")
+    parser.add_argument("--output", type=str, default="outputs/evaluation_results.json", help="结果保存路径")
+    args, unknown = parser.parse_known_args()
+    return args, unknown
+
+
+def _get_config(config, *keys, default=None):
+    value = config
+    for key in keys:
+        if isinstance(value, dict):
+            value = value.get(key, default)
+        else:
+            value = getattr(value, key, default)
+        if value is default:
+            break
+    return value
+
+
+def _load_config(path, cli_overrides=None):
+    if OmegaConf is not None:
+        config = OmegaConf.load(path)
+        if cli_overrides:
+            config = OmegaConf.merge(config, OmegaConf.from_cli(cli_overrides))
+        return config
+
+    with open(path, "r", encoding="utf-8") as fin:
+        config = yaml.safe_load(fin)
+    if cli_overrides:
+        print("Warning: OmegaConf is not installed; CLI overrides are ignored.")
+    return config
+
+
+def load_test_split(config):
+    dataset_name = _get_config(config, "data", "dataset_name")
+
+    if dataset_name == "wmt":
+        try:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="test",
+            )
+        except Exception:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="validation",
+            )
+        return list(dataset["src"]), list(dataset["tgt"])
+
+    if dataset_name == "opus":
+        try:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="test",
+            )
+        except Exception:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="validation",
+            )
+        return list(dataset["src"]), list(dataset["tgt"])
+
+    if dataset_name == "custom":
+        data = load_custom_dataset(
+            train_src=_get_config(config, "data", "custom", "train_src"),
+            train_tgt=_get_config(config, "data", "custom", "train_tgt"),
+            val_src=_get_config(config, "data", "custom", "val_src"),
+            val_tgt=_get_config(config, "data", "custom", "val_tgt"),
+            test_src=_get_config(config, "data", "custom", "test_src"),
+            test_tgt=_get_config(config, "data", "custom", "test_tgt"),
+            preprocessing_config=_get_config(config, "data", "preprocessing"),
+        )
+        if "test" not in data:
+            raise ValueError("Custom dataset missing test split")
+        return data["test"]["src"], data["test"]["tgt"]
+
+    raise ValueError(f"Unsupported dataset_name: {dataset_name}")
+
+
+def _get_tokenizer_train_texts(config, allow_auto: bool = False) -> list[str] | None:
+    dataset_name = _get_config(config, "data", "dataset_name")
+    if dataset_name == "custom":
+        custom = _get_config(config, "data", "custom") or {}
+        data = load_custom_dataset(
+            train_src=custom.get("train_src"),
+            train_tgt=custom.get("train_tgt"),
+            val_src=custom.get("val_src"),
+            val_tgt=custom.get("val_tgt"),
+            test_src=custom.get("test_src"),
+            test_tgt=custom.get("test_tgt"),
+            preprocessing_config=_get_config(config, "data", "preprocessing"),
+        )
+        return list(data["train"]["src"]) + list(data["train"]["tgt"])
+
+    if not allow_auto:
+        return None
+
+    if dataset_name == "wmt":
+        try:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="train",
+            )
+        except Exception:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="validation",
+            )
+        return list(dataset["src"]) + list(dataset["tgt"])
+
+    if dataset_name == "opus":
+        try:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="train",
+            )
+        except Exception:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="validation",
+            )
+        return list(dataset["src"]) + list(dataset["tgt"])
+
+    return None
+
+
+def build_model_and_tokenizer(config, device):
+    model_type = _get_config(config, "model", "type")
+    if model_type == "transformer_scratch":
+        tokenizer_config = _get_config(config, "tokenizer") or {}
+        tokenizer_path = tokenizer_config.get("path") or tokenizer_config.get("tokenizer_path")
+        tokenizer_type = tokenizer_config.get("type", "bpe")
+        auto_train = bool(tokenizer_config.get("auto_train", False))
+        if tokenizer_type in {"bpe", "sentencepiece"} and not tokenizer_path:
+            train_texts = _get_tokenizer_train_texts(config, allow_auto=auto_train)
+            if train_texts is None:
+                raise ValueError(
+                    "BPE tokenizer requires tokenizer.path or a local custom dataset with train texts. "
+                    "Automatic WMT/OPUS download is disabled by default. "
+                    "Set tokenizer.auto_train=true to enable it, or provide tokenizer.path/pretrained tokenizer."
+                )
+            tokenizer = build_tokenizer(tokenizer_config, train_texts=train_texts)
+        else:
+            tokenizer = build_tokenizer(tokenizer_config)
+        model = TransformerTranslationModel(
+            src_vocab_size=tokenizer.vocab_size,
+            tgt_vocab_size=tokenizer.vocab_size,
+            d_model=_get_config(config, "model", "transformer", "d_model"),
+            nhead=_get_config(config, "model", "transformer", "nhead"),
+            num_encoder_layers=_get_config(config, "model", "transformer", "num_encoder_layers"),
+            num_decoder_layers=_get_config(config, "model", "transformer", "num_decoder_layers"),
+            dim_feedforward=_get_config(config, "model", "transformer", "dim_feedforward"),
+            dropout=_get_config(config, "model", "transformer", "dropout"),
+            activation=_get_config(config, "model", "transformer", "activation"),
+            max_seq_len=_get_config(config, "model", "transformer", "max_seq_len"),
+            use_flash_attention=_get_config(config, "model", "transformer", "use_flash_attention"),
+            use_rotary_embedding=_get_config(config, "model", "transformer", "use_rotary_embedding"),
+            pre_norm=_get_config(config, "model", "transformer", "pre_norm"),
+            pad_id=tokenizer.pad_token_id,
+        )
+        return model.to(device), tokenizer
+
+    model, hf_tokenizer = load_pretrained_model(
+        config.model.pretrained.model_name,
+        config.model.pretrained.src_lang,
+        config.model.pretrained.tgt_lang,
+        device=str(device),
+    )
+    tokenizer = TokenizerWrapper(
+        hf_tokenizer,
+        pad_token=getattr(hf_tokenizer, "pad_token", "<pad>"),
+        unk_token=getattr(hf_tokenizer, "unk_token", "<unk>"),
+        bos_token=getattr(hf_tokenizer, "bos_token", "<s>"),
+        eos_token=getattr(hf_tokenizer, "eos_token", "</s>"),
+    )
+    return model, tokenizer
+
+
+def load_checkpoint(model, checkpoint_path, device):
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    if isinstance(checkpoint, dict):
+        if "model_state_dict" in checkpoint:
+            model.load_state_dict(checkpoint["model_state_dict"])
+        elif "state_dict" in checkpoint:
+            model.load_state_dict(checkpoint["state_dict"])
+        else:
+            try:
+                model.load_state_dict(checkpoint)
+            except Exception as exc:
+                raise ValueError("Checkpoint does not contain a valid model state dict") from exc
+    else:
+        raise ValueError("Unsupported checkpoint format")
+    return model
+
+
+def main():
+    args, cli_overrides = parse_args()
+
+    print("=" * 60)
+    print("  EasyTranslate - Evaluation")
+    print("=" * 60)
+
+    config = _load_config(args.config, cli_overrides)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model, tokenizer = build_model_and_tokenizer(config, device)
+    model = load_checkpoint(model, args.checkpoint, device)
+
+    src_texts, tgt_texts = load_test_split(config)
+
+    dataset = TranslationDataset(
+        src_texts=src_texts,
+        tgt_texts=tgt_texts,
+        tokenizer=tokenizer,
+        max_src_len=_get_config(config, "data", "preprocessing", "max_src_len"),
+        max_tgt_len=_get_config(config, "data", "preprocessing", "max_tgt_len"),
+    )
+    collator = TranslationCollator(pad_token_id=tokenizer.pad_token_id)
+    dataloader = DataLoader(
+        dataset,
+        batch_size=config.data.dataloader.batch_size,
+        shuffle=False,
+        num_workers=int(config.data.dataloader.num_workers),
+        pin_memory=bool(config.data.dataloader.pin_memory),
+        collate_fn=collator,
+    )
+
+    evaluator = Evaluator(model, tokenizer, config)
+    results = evaluator.evaluate(dataloader, src_texts=src_texts, ref_texts=tgt_texts)
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with output_path.open("w", encoding="utf-8") as fout:
+        json.dump(results, fout, ensure_ascii=False, indent=2)
+
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/translate.py

@@ -1,82 +1,316 @@
-"""
-交互式翻译推理脚本
-
-使用方式:
-    # 命令行交互翻译
-    python scripts/translate.py --checkpoint checkpoints/best_model.pt
-
-    # 翻译文件
-    python scripts/translate.py --checkpoint checkpoints/best_model.pt --input input.txt --output output.txt
-
-    # 启动 Gradio Web UI
-    python scripts/translate.py --checkpoint checkpoints/best_model.pt --web
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="EasyTranslate Inference")
-    parser.add_argument("--config", type=str, default="configs/default_config.yaml")
-    parser.add_argument("--checkpoint", type=str, required=True)
-    parser.add_argument("--input", type=str, default=None, help="输入文件路径")
-    parser.add_argument("--output", type=str, default=None, help="输出文件路径")
-    parser.add_argument("--web", action="store_true", help="启动 Gradio Web UI")
-    return parser.parse_args()
-
-
-def interactive_translate(evaluator):
-    """
-    命令行交互翻译。
-
-    TODO [Person D]:
-    1. 循环读取用户输入
-    2. 调用 evaluator.translate_single()
-    3. 打印翻译结果
-    4. 输入 'quit' 退出
-    """
-    raise NotImplementedError("TODO: Person D 实现 interactive_translate")
-
-
-def translate_file(evaluator, input_path: str, output_path: str):
-    """
-    文件翻译。
-
-    TODO [Person D]:
-    1. 读取输入文件 (一行一句)
-    2. 批量翻译
-    3. 将结果写入输出文件
-    """
-    raise NotImplementedError("TODO: Person D 实现 translate_file")
-
-
-def launch_web_ui(evaluator):
-    """
-    启动 Gradio Web UI。
-
-    TODO [Person D]:
-    1. 创建 Gradio Interface
-    2. 输入: 英文文本框
-    3. 输出: 中文翻译结果
-    4. 调用 evaluator.translate_single()
-    """
-    raise NotImplementedError("TODO: Person D 实现 launch_web_ui")
-
-
-def main():
-    args = parse_args()
-
-    print("=" * 60)
-    print("  EasyTranslate - Translation")
-    print("=" * 60)
-
-    # TODO: 加载模型、构建 evaluator，然后根据参数选择模式
-    raise NotImplementedError("TODO: 实现推理主流程")
-
-
-if __name__ == "__main__":
-    main()
+"""
+交互式翻译推理脚本
+
+使用方式:
+    # 命令行交互翻译
+    python scripts/translate.py --checkpoint checkpoints/best_model.pt
+
+    # 翻译文件
+    python scripts/translate.py --checkpoint checkpoints/best_model.pt --input input.txt --output output.txt
+
+    # 启动 Streamlit Web UI（无需模型即可预览界面）
+    python scripts/translate.py --web
+    # 或者带模型启动翻译
+    python scripts/translate.py --checkpoint checkpoints/best_model.pt --web
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+try:
+    from omegaconf import OmegaConf
+except ImportError:  # pragma: no cover
+    OmegaConf = None
+    import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+import torch
+
+from easytranslate.data.collator import TranslationCollator
+from easytranslate.data.dataset import (
+    TranslationDataset,
+    load_custom_dataset,
+    load_opus_dataset,
+    load_wmt_dataset,
+)
+from easytranslate.data.tokenizer import TokenizerWrapper, build_tokenizer
+from easytranslate.evaluation.evaluator import Evaluator
+from easytranslate.model import TransformerTranslationModel
+from easytranslate.model.finetune import load_pretrained_model
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="EasyTranslate Inference")
+    parser.add_argument("--config", type=str, default="configs/default_config.yaml")
+    parser.add_argument("--checkpoint", type=str, default=None)
+    parser.add_argument("--input", type=str, default=None, help="输入文件路径")
+    parser.add_argument("--output", type=str, default=None, help="输出文件路径")
+    parser.add_argument("--web", action="store_true", help="启动 Streamlit Web UI")
+    parser.add_argument("--streamlit-app", action="store_true", help=argparse.SUPPRESS)
+    args, unknown = parser.parse_known_args()
+    return args, unknown
+
+
+def _get_config(config, *keys, default=None):
+    value = config
+    for key in keys:
+        if isinstance(value, dict):
+            value = value.get(key, default)
+        else:
+            value = getattr(value, key, default)
+        if value is default:
+            break
+    return value
+
+
+def _load_config(path, cli_overrides=None):
+    if OmegaConf is not None:
+        config = OmegaConf.load(path)
+        if cli_overrides:
+            config = OmegaConf.merge(config, OmegaConf.from_cli(cli_overrides))
+        return config
+
+    with open(path, "r", encoding="utf-8") as fin:
+        config = yaml.safe_load(fin)
+    if cli_overrides:
+        print("Warning: OmegaConf is not installed; CLI overrides are ignored.")
+    return config
+
+
+def interactive_translate(evaluator):
+    print("输入英⽂句⼦，按回车翻译；输入 'quit' 退出。")
+    while True:
+        try:
+            text = input("> ").strip()
+        except EOFError:
+            break
+        if not text:
+            continue
+        if text.lower() in {"quit", "exit"}:
+            break
+        translation = evaluator.translate_single(text)
+        print(translation)
+
+
+def translate_file(evaluator, input_path: str, output_path: str):
+    source_lines = []
+    with Path(input_path).open("r", encoding="utf-8") as fin:
+        for line in fin:
+            line = line.strip()
+            if line:
+                source_lines.append(line)
+
+    translations = evaluator.translate(source_lines)
+
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    with output_file.open("w", encoding="utf-8") as fout:
+        for line in translations:
+            fout.write(f"{line}\n")
+
+    print(f"Translation complete: {len(translations)} lines written to {output_path}")
+
+
+def launch_streamlit_app(args):
+    import streamlit as st
+
+    @st.cache_resource
+    def load_evaluator():
+        config = _load_config(args.config)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model, tokenizer = build_model_and_tokenizer(config, device)
+        model = load_checkpoint(model, args.checkpoint, device)
+        return Evaluator(model, tokenizer, config)
+
+    st.set_page_config(page_title="EasyTranslate", layout="wide")
+    st.title("EasyTranslate")
+    st.write("English to Chinese translation powered by EasyTranslate.")
+
+    if args.checkpoint is None:
+        st.warning(
+            "当前未提供模型 checkpoint，页面仅用于预览界面效果。"
+            " 如需翻译，请传入 --checkpoint 或先训练生成模型。"
+        )
+
+    input_text = st.text_area("English Input", value="", height=200)
+    if st.button("Translate"):
+        if not input_text.strip():
+            st.warning("请输入要翻译的英文文本。")
+        elif args.checkpoint is None:
+            st.error("未提供 checkpoint，无法执行翻译。请使用 --checkpoint 参数启动。")
+        else:
+            with st.spinner("Translating..."):
+                try:
+                    evaluator = load_evaluator()
+                    translation = evaluator.translate_single(input_text.strip())
+                    st.text_area("Chinese Translation", value=translation, height=200)
+                except Exception as exc:
+                    st.error(f"模型加载或翻译失败：{exc}")
+
+    st.markdown("---")
+    st.caption("此页面用于展示前端界面；在未提供模型时，翻译功能会被禁用。")
+
+
+def launch_streamlit_process(args):
+    script_path = Path(__file__).resolve()
+    cmd = [sys.executable, "-m", "streamlit", "run", str(script_path), "--", "--streamlit-app", "--config", args.config]
+    if args.checkpoint:
+        cmd.extend(["--checkpoint", args.checkpoint])
+    if args.input:
+        cmd.extend(["--input", args.input])
+    if args.output:
+        cmd.extend(["--output", args.output])
+    subprocess.run(cmd, check=True)
+
+
+def _get_tokenizer_train_texts(config, allow_auto: bool = False) -> list[str] | None:
+    dataset_name = _get_config(config, "data", "dataset_name")
+    if dataset_name == "custom":
+        custom = _get_config(config, "data", "custom") or {}
+        data = load_custom_dataset(
+            train_src=custom.get("train_src"),
+            train_tgt=custom.get("train_tgt"),
+            val_src=custom.get("val_src"),
+            val_tgt=custom.get("val_tgt"),
+            test_src=custom.get("test_src"),
+            test_tgt=custom.get("test_tgt"),
+            preprocessing_config=_get_config(config, "data", "preprocessing"),
+        )
+        return list(data["train"]["src"]) + list(data["train"]["tgt"])
+
+    if not allow_auto:
+        return None
+
+    if dataset_name == "wmt":
+        try:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="train",
+            )
+        except Exception:
+            dataset = load_wmt_dataset(
+                year=_get_config(config, "data", "wmt", "year"),
+                language_pair=_get_config(config, "data", "wmt", "language_pair"),
+                split="validation",
+            )
+        return list(dataset["src"]) + list(dataset["tgt"])
+
+    if dataset_name == "opus":
+        try:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="train",
+            )
+        except Exception:
+            dataset = load_opus_dataset(
+                subset=_get_config(config, "data", "opus", "subset"),
+                split="validation",
+            )
+        return list(dataset["src"]) + list(dataset["tgt"])
+
+    return None
+
+
+def build_model_and_tokenizer(config, device):
+    model_type = _get_config(config, "model", "type")
+    if model_type == "transformer_scratch":
+        tokenizer_config = _get_config(config, "tokenizer") or {}
+        tokenizer_path = tokenizer_config.get("path") or tokenizer_config.get("tokenizer_path")
+        tokenizer_type = tokenizer_config.get("type", "bpe")
+        auto_train = bool(tokenizer_config.get("auto_train", False))
+        if tokenizer_type in {"bpe", "sentencepiece"} and not tokenizer_path:
+            train_texts = _get_tokenizer_train_texts(config, allow_auto=auto_train)
+            if train_texts is None:
+                raise ValueError(
+                    "BPE tokenizer requires tokenizer.path or a local custom dataset with train texts. "
+                    "Automatic download from WMT/OPUS is disabled by default. "
+                    "Set tokenizer.auto_train=true to enable it, or provide tokenizer.path/pretrained tokenizer."
+                )
+            tokenizer = build_tokenizer(tokenizer_config, train_texts=train_texts)
+        else:
+            tokenizer = build_tokenizer(tokenizer_config)
+
+        model = TransformerTranslationModel(
+            src_vocab_size=tokenizer.vocab_size,
+            tgt_vocab_size=tokenizer.vocab_size,
+            d_model=_get_config(config, "model", "transformer", "d_model"),
+            nhead=_get_config(config, "model", "transformer", "nhead"),
+            num_encoder_layers=_get_config(config, "model", "transformer", "num_encoder_layers"),
+            num_decoder_layers=_get_config(config, "model", "transformer", "num_decoder_layers"),
+            dim_feedforward=_get_config(config, "model", "transformer", "dim_feedforward"),
+            dropout=_get_config(config, "model", "transformer", "dropout"),
+            activation=_get_config(config, "model", "transformer", "activation"),
+            max_seq_len=_get_config(config, "model", "transformer", "max_seq_len"),
+            use_flash_attention=_get_config(config, "model", "transformer", "use_flash_attention"),
+            use_rotary_embedding=_get_config(config, "model", "transformer", "use_rotary_embedding"),
+            pre_norm=_get_config(config, "model", "transformer", "pre_norm"),
+            pad_id=tokenizer.pad_token_id,
+        )
+        return model.to(device), tokenizer
+
+    model, hf_tokenizer = load_pretrained_model(
+        config.model.pretrained.model_name,
+        config.model.pretrained.src_lang,
+        config.model.pretrained.tgt_lang,
+        device=str(device),
+    )
+    tokenizer = TokenizerWrapper(
+        hf_tokenizer,
+        pad_token=getattr(hf_tokenizer, "pad_token", "<pad>"),
+        unk_token=getattr(hf_tokenizer, "unk_token", "<unk>"),
+        bos_token=getattr(hf_tokenizer, "bos_token", "<s>"),
+        eos_token=getattr(hf_tokenizer, "eos_token", "</s>"),
+    )
+    return model, tokenizer
+
+
+def load_checkpoint(model, checkpoint_path, device):
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    if isinstance(checkpoint, dict):
+        if "model_state_dict" in checkpoint:
+            model.load_state_dict(checkpoint["model_state_dict"])
+        elif "state_dict" in checkpoint:
+            model.load_state_dict(checkpoint["state_dict"])
+        else:
+            try:
+                model.load_state_dict(checkpoint)
+            except Exception as exc:
+                raise ValueError("Checkpoint does not contain a valid model state dict") from exc
+    else:
+        raise ValueError("Unsupported checkpoint format")
+    return model
+
+
+def main():
+    args, cli_overrides = parse_args()
+
+    print("=" * 60)
+    print("  EasyTranslate - Translation")
+    print("=" * 60)
+
+    if args.web and not args.streamlit_app:
+        launch_streamlit_process(args)
+        return
+
+    if args.streamlit_app:
+        launch_streamlit_app(args)
+        return
+
+    config = _load_config(args.config, cli_overrides)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model, tokenizer = build_model_and_tokenizer(config, device)
+    model = load_checkpoint(model, args.checkpoint, device)
+    evaluator = Evaluator(model, tokenizer, config)
+
+    if args.input and args.output:
+        translate_file(evaluator, args.input, args.output)
+    else:
+        interactive_translate(evaluator)
+
+
+if __name__ == "__main__":
+    main()

src/easytranslate/evaluation/__init__.py

@@ -1,16 +1,16 @@
-"""评估与推理模块 (Person D 负责)"""
-
-from easytranslate.evaluation.metrics import compute_bleu, compute_comet, compute_chrf, compute_all_metrics
-from easytranslate.evaluation.decoding import greedy_decode, beam_search_decode, sample_decode
-from easytranslate.evaluation.evaluator import Evaluator
-
-__all__ = [
-    "compute_bleu",
-    "compute_comet",
-    "compute_chrf",
-    "compute_all_metrics",
-    "greedy_decode",
-    "beam_search_decode",
-    "sample_decode",
-    "Evaluator",
-]
+"""评估与推理模块 (Person D 负责)"""
+
+from easytranslate.evaluation.metrics import compute_bleu, compute_comet, compute_chrf, compute_all_metrics
+from easytranslate.evaluation.decoding import greedy_decode, beam_search_decode, sample_decode
+from easytranslate.evaluation.evaluator import Evaluator
+
+__all__ = [
+    "compute_bleu",
+    "compute_comet",
+    "compute_chrf",
+    "compute_all_metrics",
+    "greedy_decode",
+    "beam_search_decode",
+    "sample_decode",
+    "Evaluator",
+]

src/easytranslate/evaluation/decoding.py

@@ -1,129 +1,219 @@
-"""
-解码策略模块 — Person D 负责实现
-
-功能要求:
-1. greedy_decode: 贪心解码
-2. beam_search_decode: 束搜索解码
-3. sample_decode: 采样解码 (temperature, top-k, top-p)
-
-技术要点:
-- Beam Search 是翻译任务最常用的解码策略
-- 需要高效处理批量解码
-- 支持长度惩罚 (length penalty) 和重复惩罚 (no_repeat_ngram)
-- 对于预训练模型，可以直接使用 model.generate()
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-logger = logging.getLogger(__name__)
-
-
-@torch.no_grad()
-def greedy_decode(
-    model: nn.Module,
-    src_ids: torch.Tensor,          # [B, S]
-    src_padding_mask: torch.BoolTensor,  # [B, S]
-    bos_id: int,
-    eos_id: int,
-    max_len: int = 256,
-) -> torch.Tensor:
-    """
-    贪心解码。
-
-    TODO [Person D]: 实现以下逻辑:
-    1. encoder_output = model.encode(src_ids, src_padding_mask)
-    2. 初始化 decoder input: [B, 1] 全为 bos_id
-    3. for step in range(max_len):
-       a. logits = model.decode_step(decoder_input, encoder_output, src_padding_mask)
-       b. next_token = logits.argmax(dim=-1)
-       c. decoder_input = concat(decoder_input, next_token)
-       d. 如果所有序列都生成了 eos_id，则提前终止
-    4. 返回生成的 token ids [B, T]
-    """
-    raise NotImplementedError("TODO: Person D 实现 greedy_decode")
-
-
-@torch.no_grad()
-def beam_search_decode(
-    model: nn.Module,
-    src_ids: torch.Tensor,          # [B, S]
-    src_padding_mask: torch.BoolTensor,
-    bos_id: int,
-    eos_id: int,
-    beam_size: int = 5,
-    max_len: int = 256,
-    length_penalty: float = 1.0,
-    no_repeat_ngram_size: int = 0,
-) -> torch.Tensor:
-    """
-    束搜索解码。
-
-    TODO [Person D]: 实现以下逻辑:
-    1. encoder_output = model.encode(src_ids, src_padding_mask)
-    2. 将 encoder_output 扩展为 beam_size 份: [B*beam, S, D]
-    3. 初始化 beam:
-       - beam_scores: [B, beam_size] 初始为 0
-       - beam_tokens: [B, beam_size, 1] 初始为 bos_id
-    4. for step in range(max_len):
-       a. 对每个 beam 计算 logits
-       b. log_probs = log_softmax(logits)
-       c. (可选) 应用 no_repeat_ngram 约束
-       d. scores = beam_scores + log_probs
-       e. 选择 top-k candidates (k = beam_size)
-       f. 更新 beam_tokens 和 beam_scores
-       g. 将已完成的 beam 移到 finished pool
-    5. 对 finished beams 应用 length_penalty:
-       score = score / (length ^ length_penalty)
-    6. 选择得分最高的序列
-    7. 返回最佳翻译 [B, T]
-
-    这是翻译任务最关键的解码算法，请仔细实现。
-    """
-    raise NotImplementedError("TODO: Person D 实现 beam_search_decode")
-
-
-@torch.no_grad()
-def sample_decode(
-    model: nn.Module,
-    src_ids: torch.Tensor,
-    src_padding_mask: torch.BoolTensor,
-    bos_id: int,
-    eos_id: int,
-    max_len: int = 256,
-    temperature: float = 1.0,
-    top_k: int = 0,
-    top_p: float = 1.0,
-) -> torch.Tensor:
-    """
-    采样解码 (支持 temperature, top-k, top-p/nucleus sampling)。
-
-    TODO [Person D]: 实现以下逻辑:
-    1. 与贪心解码类似，但每步采样而非取 argmax
-    2. 应用 temperature: logits = logits / temperature
-    3. 应用 top-k: 只保留概率最高的 k 个 token
-    4. 应用 top-p (nucleus): 只保留累积概率达到 p 的 token
-    5. 从过滤后的分布中采样: torch.multinomial
-    """
-    raise NotImplementedError("TODO: Person D 实现 sample_decode")
-
-
-def _apply_no_repeat_ngram(
-    logits: torch.Tensor,
-    generated_tokens: torch.Tensor,
-    ngram_size: int,
-) -> torch.Tensor:
-    """
-    防止生成重复的 n-gram。
-
-    TODO [Person D]:
-    1. 从 generated_tokens 中提取所有已出现的 (ngram_size-1)-gram
-    2. 对于每个可能导致重复 ngram 的 next token，将其 logits 设为 -inf
-    """
-    raise NotImplementedError("TODO: Person D 实现 _apply_no_repeat_ngram")
+"""
+解码策略模块 — Person D 负责实现
+
+功能要求:
+1. greedy_decode: 贪心解码
+2. beam_search_decode: 束搜索解码
+3. sample_decode: 采样解码 (temperature, top-k, top-p)
+
+技术要点:
+- Beam Search 是翻译任务最常用的解码策略
+- 需要高效处理批量解码
+- 支持长度惩罚 (length penalty) 和重复惩罚 (no_repeat_ngram)
+- 对于预训练模型，可以直接使用 model.generate()
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+logger = logging.getLogger(__name__)
+
+
+def _apply_no_repeat_ngram(
+    logits: torch.Tensor,
+    generated_tokens: torch.Tensor,
+    ngram_size: int,
+) -> torch.Tensor:
+    """
+    防止生成重复的 n-gram。
+    """
+    if ngram_size <= 1:
+        return logits
+
+    batch_size, vocab_size = logits.size()
+    for batch_idx in range(batch_size):
+        tokens = generated_tokens[batch_idx].tolist()
+        if len(tokens) < ngram_size - 1:
+            continue
+
+        banned_tokens: set[int] = set()
+        ngram_map: dict[tuple[int, ...], set[int]] = {}
+        for i in range(len(tokens) - ngram_size + 1):
+            prefix = tuple(tokens[i : i + ngram_size - 1])
+            next_token = tokens[i + ngram_size - 1]
+            ngram_map.setdefault(prefix, set()).add(next_token)
+
+        prefix = tuple(tokens[-(ngram_size - 1) :])
+        if prefix in ngram_map:
+            banned_tokens = ngram_map[prefix]
+            logits[batch_idx, list(banned_tokens)] = float("-inf")
+
+    return logits
+
+
+@torch.no_grad()
+def greedy_decode(
+    model: nn.Module,
+    src_ids: torch.Tensor,
+    src_padding_mask: torch.BoolTensor,
+    bos_id: int,
+    eos_id: int,
+    max_len: int = 256,
+) -> torch.Tensor:
+    """
+    贪心解码。
+    """
+    encoder_output = model.encode(src_ids, src_padding_mask)
+    batch_size = src_ids.size(0)
+    device = src_ids.device
+    generated = torch.full((batch_size, 1), bos_id, dtype=torch.long, device=device)
+    finished = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+    for _ in range(max_len):
+        logits = model.decode_step(generated, encoder_output, src_padding_mask)
+        next_token = logits.argmax(dim=-1, keepdim=True)
+        generated = torch.cat([generated, next_token], dim=1)
+        finished = finished | next_token.squeeze(-1).eq(eos_id)
+        if finished.all():
+            break
+
+    return generated
+
+
+@torch.no_grad()
+def beam_search_decode(
+    model: nn.Module,
+    src_ids: torch.Tensor,
+    src_padding_mask: torch.BoolTensor,
+    bos_id: int,
+    eos_id: int,
+    beam_size: int = 5,
+    max_len: int = 256,
+    length_penalty: float = 1.0,
+    no_repeat_ngram_size: int = 0,
+) -> torch.Tensor:
+    """
+    束搜索解码。
+    """
+    batch_size, seq_len = src_ids.size()
+    device = src_ids.device
+
+    encoder_output = model.encode(src_ids, src_padding_mask)
+    encoder_output = encoder_output.unsqueeze(1).expand(batch_size, beam_size, -1, -1)
+    encoder_output = encoder_output.reshape(batch_size * beam_size, seq_len, -1)
+    src_padding_mask = src_padding_mask.unsqueeze(1).expand(batch_size, beam_size, seq_len)
+    src_padding_mask = src_padding_mask.reshape(batch_size * beam_size, seq_len)
+
+    beam_scores = torch.full((batch_size, beam_size), float("-inf"), device=device)
+    beam_scores[:, 0] = 0.0
+    generated = torch.full((batch_size, beam_size, 1), bos_id, dtype=torch.long, device=device)
+    finished = torch.zeros((batch_size, beam_size), dtype=torch.bool, device=device)
+
+    for _ in range(max_len):
+        flat_generated = generated.view(batch_size * beam_size, -1)
+        logits = model.decode_step(flat_generated, encoder_output, src_padding_mask)
+        log_probs = F.log_softmax(logits, dim=-1)
+
+        if no_repeat_ngram_size > 0:
+            log_probs = _apply_no_repeat_ngram(log_probs, flat_generated, no_repeat_ngram_size)
+
+        finished_flat = finished.view(batch_size * beam_size)
+        if finished_flat.any():
+            log_probs[finished_flat] = float("-inf")
+            log_probs[finished_flat, eos_id] = 0.0
+
+        vocab_size = log_probs.size(-1)
+        scores = beam_scores.unsqueeze(-1) + log_probs.view(batch_size, beam_size, vocab_size)
+        scores_flat = scores.view(batch_size, -1)
+        topk_scores, topk_indices = scores_flat.topk(beam_size, dim=-1)
+
+        beam_indices = topk_indices // vocab_size
+        token_indices = topk_indices % vocab_size
+
+        next_generated = []
+        next_finished = []
+        for batch_idx in range(batch_size):
+            selected_beams = beam_indices[batch_idx]
+            selected_tokens = token_indices[batch_idx]
+            next_seq = generated[batch_idx, selected_beams]
+            next_seq = torch.cat([next_seq, selected_tokens.unsqueeze(-1)], dim=-1)
+            next_generated.append(next_seq)
+            next_finished.append(
+                finished[batch_idx, selected_beams]
+                | selected_tokens.eq(eos_id)
+            )
+
+        generated = torch.stack(next_generated, dim=0)
+        finished = torch.stack(next_finished, dim=0)
+        beam_scores = topk_scores
+
+        if finished.all():
+            break
+
+    length = generated.size(1)
+    penalty = float(length) ** float(length_penalty)
+    final_scores = beam_scores / penalty
+    best_indices = final_scores.argmax(dim=-1)
+    output = generated[torch.arange(batch_size, device=device), best_indices]
+    return output
+
+
+@torch.no_grad()
+def sample_decode(
+    model: nn.Module,
+    src_ids: torch.Tensor,
+    src_padding_mask: torch.BoolTensor,
+    bos_id: int,
+    eos_id: int,
+    max_len: int = 256,
+    temperature: float = 1.0,
+    top_k: int = 0,
+    top_p: float = 1.0,
+) -> torch.Tensor:
+    """
+    采样解码 (支持 temperature, top-k, top-p/nucleus sampling)。
+    """
+    encoder_output = model.encode(src_ids, src_padding_mask)
+    batch_size = src_ids.size(0)
+    device = src_ids.device
+    generated = torch.full((batch_size, 1), bos_id, dtype=torch.long, device=device)
+    finished = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+    for _ in range(max_len):
+        logits = model.decode_step(generated, encoder_output, src_padding_mask)
+        logits = logits / max(temperature, 1e-8)
+
+        if top_k > 0:
+            top_k = min(top_k, logits.size(-1))
+            values, indices = torch.topk(logits, top_k, dim=-1)
+            mask = torch.full_like(logits, float("-inf"))
+            logits = mask.scatter(-1, indices, values)
+
+        if 0.0 < top_p < 1.0:
+            sorted_logits, sorted_indices = torch.sort(logits, descending=True, dim=-1)
+            probs = F.softmax(sorted_logits, dim=-1)
+            cumulative_probs = torch.cumsum(probs, dim=-1)
+            cutoff = cumulative_probs > top_p
+            cutoff[:, 1:] = cutoff[:, :-1].clone()
+            cutoff[:, 0] = False
+            sorted_logits[cutoff] = float("-inf")
+            logits = torch.zeros_like(logits).scatter(-1, sorted_indices, sorted_logits)
+
+        probs = F.softmax(logits, dim=-1)
+        next_token = torch.multinomial(probs, num_samples=1)
+        next_token = next_token.clamp(min=0)
+
+        next_token = torch.where(finished.unsqueeze(-1), torch.full_like(next_token, eos_id), next_token)
+        generated = torch.cat([generated, next_token], dim=1)
+        finished = finished | next_token.squeeze(-1).eq(eos_id)
+
+        if finished.all():
+            break
+
+    return generated

src/easytranslate/evaluation/evaluator.py

@@ -1,76 +1,208 @@
-"""
-评估器模块 — Person D 负责实现
-
-功能要求:
-将解码和评估指标整合为统一的评估接口。
-
-使用方法:
-    evaluator = Evaluator(model, tokenizer, config)
-    results = evaluator.evaluate(test_loader)
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-import torch
-import torch.nn as nn
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-
-from easytranslate.evaluation.metrics import compute_all_metrics
-from easytranslate.evaluation.decoding import greedy_decode, beam_search_decode, sample_decode
-
-logger = logging.getLogger(__name__)
-
-
-class Evaluator:
-    """
-    翻译模型评估器。
-
-    TODO [Person D]: 实现以下方法。
-    """
-
-    def __init__(self, model: nn.Module, tokenizer, config: dict):
-        """
-        TODO [Person D]:
-        1. 保存 model, tokenizer, config
-        2. 从 config 读取解码策略和评估指标配置
-        3. 根据策略选择解码函数
-        """
-        raise NotImplementedError("TODO: Person D 实现 Evaluator.__init__")
-
-    def evaluate(
-        self,
-        dataloader: DataLoader,
-        src_texts: Optional[list[str]] = None,
-        ref_texts: Optional[list[str]] = None,
-    ) -> dict:
-        """
-        在给定数据上进行评估。
-
-        TODO [Person D]: 实现以下逻辑:
-        1. model.eval()
-        2. 遍历 dataloader，使用选定的解码策略生成翻译
-        3. 将生成的 token ids 解码为文本
-        4. 调用 compute_all_metrics 计算指标
-        5. 返回评估结果 dict
-        """
-        raise NotImplementedError("TODO: Person D 实现 evaluate")
-
-    def translate(self, texts: list[str]) -> list[str]:
-        """
-        翻译一批文本。
-
-        TODO [Person D]:
-        1. tokenize 输入文本
-        2. 调用解码函数生成翻译
-        3. 解码为文本
-        4. 返回翻译结果列表
-        """
-        raise NotImplementedError("TODO: Person D 实现 translate")
-
-    def translate_single(self, text: str) -> str:
-        """翻译单条文本。"""
-        return self.translate([text])[0]
+"""
+评估器模块 — Person D 负责实现
+
+功能要求:
+将解码和评估指标整合为统一的评估接口。
+
+使用方法:
+    evaluator = Evaluator(model, tokenizer, config)
+    results = evaluator.evaluate(test_loader)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from torch.nn.utils.rnn import pad_sequence
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from easytranslate.evaluation.metrics import compute_all_metrics
+from easytranslate.evaluation.decoding import greedy_decode, beam_search_decode, sample_decode
+
+logger = logging.getLogger(__name__)
+
+
+def _get_config_value(config, key_path, default=None):
+    if config is None:
+        return default
+    if isinstance(config, dict):
+        value = config
+        for key in key_path:
+            value = value.get(key, default)
+            if value is default:
+                break
+        return value
+    value = config
+    for key in key_path:
+        value = getattr(value, key, default)
+        if value is default:
+            break
+    return value
+
+
+class Evaluator:
+    """
+    翻译模型评估器。
+    """
+
+    def __init__(self, model: nn.Module, tokenizer, config: dict):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.config = config or {}
+
+        self.evaluation_config = _get_config_value(self.config, ["evaluation"], {})
+        self.decoding_config = _get_config_value(self.evaluation_config, ["decoding"], {})
+        self.metrics = _get_config_value(self.evaluation_config, ["metrics"], ["bleu", "comet", "chrf", "ter"])
+        self.strategy = self.decoding_config.get("strategy", "beam_search") if isinstance(self.decoding_config, dict) else getattr(self.decoding_config, "strategy", "beam_search")
+
+        self.bos_id = self.tokenizer.bos_token_id
+        self.eos_id = self.tokenizer.eos_token_id
+        self.pad_id = self.tokenizer.pad_token_id
+
+        self.max_decode_len = self.decoding_config.get("max_decode_len", 256) if isinstance(self.decoding_config, dict) else getattr(self.decoding_config, "max_decode_len", 256)
+        self.beam_size = self.decoding_config.get("beam_size", 5) if isinstance(self.decoding_config, dict) else getattr(self.decoding_config, "beam_size", 5)
+        self.length_penalty = self.decoding_config.get("length_penalty", 1.0) if isinstance(self.decoding_config, dict) else getattr(self.decoding_config, "length_penalty", 1.0)
+        self.no_repeat_ngram_size = self.decoding_config.get("no_repeat_ngram_size", 0) if isinstance(self.decoding_config, dict) else getattr(self.decoding_config, "no_repeat_ngram_size", 0)
+        self.temperature = self.decoding_config.get("sampling", {}).get("temperature", 1.0) if isinstance(self.decoding_config, dict) else getattr(getattr(self.decoding_config, "sampling", {}), "temperature", 1.0)
+        self.top_k = self.decoding_config.get("sampling", {}).get("top_k", 0) if isinstance(self.decoding_config, dict) else getattr(getattr(self.decoding_config, "sampling", {}), "top_k", 0)
+        self.top_p = self.decoding_config.get("sampling", {}).get("top_p", 1.0) if isinstance(self.decoding_config, dict) else getattr(getattr(self.decoding_config, "sampling", {}), "top_p", 1.0)
+
+        self.use_generate = hasattr(self.model, "generate") and not (hasattr(self.model, "encode") and hasattr(self.model, "decode_step"))
+
+    def _decode(self, src_ids: torch.Tensor, src_padding_mask: torch.BoolTensor) -> torch.Tensor:
+        if self.use_generate:
+            generate_kwargs = {
+                "max_length": self.max_decode_len,
+                "early_stopping": True,
+            }
+            if self.strategy == "beam_search":
+                generate_kwargs.update(
+                    {
+                        "num_beams": self.beam_size,
+                        "length_penalty": self.length_penalty,
+                        "no_repeat_ngram_size": self.no_repeat_ngram_size,
+                    }
+                )
+            elif self.strategy == "sampling":
+                generate_kwargs.update(
+                    {
+                        "do_sample": True,
+                        "temperature": self.temperature,
+                        "top_k": self.top_k,
+                        "top_p": self.top_p,
+                        "num_beams": 1,
+                    }
+                )
+            else:
+                generate_kwargs.update({"num_beams": 1})
+
+            attention_mask = (~src_padding_mask).long()
+            return self.model.generate(input_ids=src_ids, attention_mask=attention_mask, **generate_kwargs)
+
+        if self.strategy == "beam_search":
+            return beam_search_decode(
+                self.model,
+                src_ids,
+                src_padding_mask,
+                self.bos_id,
+                self.eos_id,
+                beam_size=self.beam_size,
+                max_len=self.max_decode_len,
+                length_penalty=self.length_penalty,
+                no_repeat_ngram_size=self.no_repeat_ngram_size,
+            )
+        if self.strategy == "sampling":
+            return sample_decode(
+                self.model,
+                src_ids,
+                src_padding_mask,
+                self.bos_id,
+                self.eos_id,
+                max_len=self.max_decode_len,
+                temperature=self.temperature,
+                top_k=self.top_k,
+                top_p=self.top_p,
+            )
+        return greedy_decode(
+            self.model,
+            src_ids,
+            src_padding_mask,
+            self.bos_id,
+            self.eos_id,
+            max_len=self.max_decode_len,
+        )
+
+    def evaluate(
+        self,
+        dataloader: DataLoader,
+        src_texts: Optional[list[str]] = None,
+        ref_texts: Optional[list[str]] = None,
+    ) -> dict:
+        self.model.eval()
+        device = next(self.model.parameters()).device if any(p.requires_grad or p.is_floating_point() for p in self.model.parameters()) else torch.device("cpu")
+
+        if src_texts is None and hasattr(dataloader, "dataset") and hasattr(dataloader.dataset, "src_texts"):
+            src_texts = list(dataloader.dataset.src_texts)
+        if ref_texts is None and hasattr(dataloader, "dataset") and hasattr(dataloader.dataset, "tgt_texts"):
+            ref_texts = list(dataloader.dataset.tgt_texts)
+
+        if src_texts is None or ref_texts is None:
+            raise ValueError("Source texts and reference texts must be provided for evaluation.")
+
+        hypotheses: list[str] = []
+        sources: list[str] = []
+        references: list[str] = []
+
+        for batch_idx, batch in enumerate(tqdm(dataloader, desc="Evaluating", unit="batch")):
+            src_ids = batch["src_ids"].to(device)
+            src_padding_mask = batch.get("src_padding_mask")
+            if src_padding_mask is None:
+                src_padding_mask = src_ids.eq(self.pad_id)
+            else:
+                src_padding_mask = src_padding_mask.to(device)
+
+            output_ids = self._decode(src_ids, src_padding_mask)
+            if isinstance(output_ids, torch.Tensor):
+                output_ids = output_ids.cpu()
+
+            for sample_idx in range(output_ids.size(0)):
+                decoded = self.tokenizer.decode(output_ids[sample_idx].tolist(), skip_special_tokens=True)
+                hypotheses.append(decoded)
+
+        sources = src_texts
+        references = ref_texts
+        results = compute_all_metrics(sources, hypotheses, references, metrics=self.metrics)
+        return results
+
+    def translate(self, texts: list[str]) -> list[str]:
+        self.model.eval()
+        device = next(self.model.parameters()).device if any(p.requires_grad or p.is_floating_point() for p in self.model.parameters()) else torch.device("cpu")
+
+        input_ids = []
+        for text in texts:
+            src_tokens = self.tokenizer.encode(
+                text,
+                add_special_tokens=True,
+                max_length=_get_config_value(self.config, ["data", "preprocessing", "max_src_len"], 256),
+            )
+            input_ids.append(torch.tensor(src_tokens, dtype=torch.long, device=device))
+
+        src_ids = pad_sequence(input_ids, batch_first=True, padding_value=self.pad_id)
+        src_padding_mask = src_ids.eq(self.pad_id)
+
+        output_ids = self._decode(src_ids, src_padding_mask)
+        if isinstance(output_ids, torch.Tensor):
+            output_ids = output_ids.cpu()
+
+        translations: list[str] = []
+        for sample_idx in range(output_ids.size(0)):
+            translations.append(self.tokenizer.decode(output_ids[sample_idx].tolist(), skip_special_tokens=True))
+
+        return translations
+
+    def translate_single(self, text: str) -> str:
+        return self.translate([text])[0]

src/easytranslate/evaluation/metrics.py

@@ -1,109 +1,169 @@
-"""
-评估指标模块 — Person D 负责实现
-
-功能要求:
-1. compute_bleu: 计算 SacreBLEU 分数
-2. compute_comet: 计算 COMET 分数 (神经网络评估指标)
-3. compute_chrf: 计算 chrF++ 分数
-4. compute_ter: 计算 TER (Translation Edit Rate)
-5. compute_all_metrics: 计算所有指标
-
-技术要点:
-- SacreBLEU: 标准化的 BLEU 实现，结果可复现
-- COMET: 基于预训练语言模型的评估指标，与人类评价相关性最高
-- chrF++: 基于字符 n-gram 的 F-score，对中文尤其有用
-- TER: 编辑距离，衡量翻译后编辑量
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-def compute_bleu(
-    hypotheses: list[str],
-    references: list[str],
-    tokenize: str = "zh",
-) -> dict:
-    """
-    计算 SacreBLEU 分数。
-
-    TODO [Person D]: 实现以下逻辑:
-    1. 使用 sacrebleu.corpus_bleu(hypotheses, [references], tokenize=tokenize)
-    2. tokenize="zh" 对中文进行字符级别分词
-    3. 返回 {"bleu": score, "bleu_1": ..., "bleu_2": ..., "bleu_3": ..., "bleu_4": ..., "bp": ...}
-
-    注意: references 需要包装为 list of list (支持多参考)
-    """
-    raise NotImplementedError("TODO: Person D 实现 compute_bleu")
-
-
-def compute_comet(
-    sources: list[str],
-    hypotheses: list[str],
-    references: list[str],
-    model_name: str = "Unbabel/wmt22-comet-da",
-    batch_size: int = 16,
-    gpus: int = 1,
-) -> dict:
-    """
-    计算 COMET 分数。
-
-    TODO [Person D]: 实现以下逻辑:
-    1. 加载 COMET 模型: comet.download_model(model_name)
-    2. 构建输入数据: [{"src": s, "mt": h, "ref": r} for s, h, r in zip(...)]
-    3. 调用 model.predict(data, batch_size, gpus)
-    4. 返回 {"comet": system_score, "comet_scores": segment_scores}
-
-    COMET 需要源语言、翻译结果和参考翻译三者。
-    """
-    raise NotImplementedError("TODO: Person D 实现 compute_comet")
-
-
-def compute_chrf(
-    hypotheses: list[str],
-    references: list[str],
-) -> dict:
-    """
-    计算 chrF++ 分数。
-
-    TODO [Person D]:
-    1. 使用 sacrebleu.corpus_chrf(hypotheses, [references])
-    2. 返回 {"chrf": score}
-    """
-    raise NotImplementedError("TODO: Person D 实现 compute_chrf")
-
-
-def compute_ter(
-    hypotheses: list[str],
-    references: list[str],
-) -> dict:
-    """
-    计算 TER 分数。
-
-    TODO [Person D]:
-    1. 使用 sacrebleu.corpus_ter(hypotheses, [references])
-    2. 返回 {"ter": score}
-    """
-    raise NotImplementedError("TODO: Person D 实现 compute_ter")
-
-
-def compute_all_metrics(
-    sources: list[str],
-    hypotheses: list[str],
-    references: list[str],
-    metrics: list[str] = ["bleu", "comet", "chrf", "ter"],
-) -> dict:
-    """
-    计算所有指定的评估指标。
-
-    TODO [Person D]:
-    1. 遍历 metrics 列表
-    2. 调用对应的计算函数
-    3. 合并结果并返回
-    4. 记录每个指标的计算时间
-    """
-    raise NotImplementedError("TODO: Person D 实现 compute_all_metrics")
+"""
+评估指标模块 — Person D 负责实现
+
+功能要求:
+1. compute_bleu: 计算 SacreBLEU 分数
+2. compute_comet: 计算 COMET 分数 (神经网络评估指标)
+3. compute_chrf: 计算 chrF++ 分数
+4. compute_ter: 计算 TER (Translation Edit Rate)
+5. compute_all_metrics: 计算所有指标
+
+技术要点:
+- SacreBLEU: 标准化的 BLEU 实现，结果可复现
+- COMET: 基于预训练语言模型的评估指标，与人类评价相关性最高
+- chrF++: 基于字符 n-gram 的 F-score，对中文尤其有用
+- TER: 编辑距离，衡量翻译后编辑量
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _import_sacrebleu():
+    try:
+        import sacrebleu
+    except ImportError as exc:
+        logger.error("SacreBLEU is not installed: %s", exc)
+        raise ImportError(
+            "sacrebleu is required for BLEU/chrF/TER evaluation. "
+            "Install it with `python -m pip install sacrebleu`."
+        ) from exc
+    return sacrebleu
+
+
+def compute_bleu(
+    hypotheses: list[str],
+    references: list[str],
+    tokenize: str = "zh",
+) -> dict:
+    """
+    计算 SacreBLEU 分数。
+    """
+    if not hypotheses or not references:
+        return {
+            "bleu": 0.0,
+            "bleu_1": 0.0,
+            "bleu_2": 0.0,
+            "bleu_3": 0.0,
+            "bleu_4": 0.0,
+            "bp": 0.0,
+        }
+
+    sacrebleu = _import_sacrebleu()
+    references_list = [references]
+    bleu = sacrebleu.corpus_bleu(hypotheses, references_list, tokenize=tokenize)
+    precisions = [round(float(x), 4) for x in bleu.precisions]
+    return {
+        "bleu": round(float(bleu.score), 4),
+        "bleu_1": precisions[0] if len(precisions) > 0 else 0.0,
+        "bleu_2": precisions[1] if len(precisions) > 1 else 0.0,
+        "bleu_3": precisions[2] if len(precisions) > 2 else 0.0,
+        "bleu_4": precisions[3] if len(precisions) > 3 else 0.0,
+        "bp": round(float(getattr(bleu, "bp", 0.0)), 4),
+    }
+
+
+def compute_comet(
+    sources: list[str],
+    hypotheses: list[str],
+    references: list[str],
+    model_name: str = "Unbabel/wmt22-comet-da",
+    batch_size: int = 16,
+    gpus: int = 1,
+) -> dict:
+    """
+    计算 COMET 分数。
+    """
+    if not sources or not hypotheses or not references:
+        return {"comet": 0.0, "comet_scores": []}
+
+    try:
+        from comet import download_model, load_from_checkpoint
+    except ImportError as exc:
+        logger.error("COMET library is not installed: %s", exc)
+        raise
+
+    model_path = download_model(model_name)
+    model = load_from_checkpoint(model_path)
+
+    data = [
+        {"src": src, "mt": hyp, "ref": ref}
+        for src, hyp, ref in zip(sources, hypotheses, references)
+    ]
+    prediction = model.predict(data, batch_size=batch_size, gpus=gpus)
+
+    if isinstance(prediction, dict):
+        scores = prediction.get("scores") or prediction.get("predictions") or []
+    else:
+        scores = list(prediction)
+
+    if scores is None:
+        scores = []
+
+    scores = [float(score) for score in scores]
+    system_score = float(sum(scores) / len(scores)) if scores else 0.0
+    return {"comet": round(system_score, 4), "comet_scores": scores}
+
+
+def compute_chrf(
+    hypotheses: list[str],
+    references: list[str],
+) -> dict:
+    """
+    计算 chrF++ 分数。
+    """
+    if not hypotheses or not references:
+        return {"chrf": 0.0}
+
+    sacrebleu = _import_sacrebleu()
+    chrf = sacrebleu.corpus_chrf(hypotheses, [references])
+    return {"chrf": round(float(chrf.score), 4)}
+
+
+def compute_ter(
+    hypotheses: list[str],
+    references: list[str],
+) -> dict:
+    """
+    计算 TER 分数。
+    """
+    if not hypotheses or not references:
+        return {"ter": 0.0}
+
+    sacrebleu = _import_sacrebleu()
+    ter = sacrebleu.corpus_ter(hypotheses, [references])
+    return {"ter": round(float(ter.score), 4)}
+
+
+def compute_all_metrics(
+    sources: list[str],
+    hypotheses: list[str],
+    references: list[str],
+    metrics: list[str] = ["bleu", "comet", "chrf", "ter"],
+) -> dict:
+    """
+    计算所有指定的评估指标。
+    """
+    results: dict[str, float | list[float]] = {}
+
+    for metric in metrics:
+        start_time = time.time()
+        if metric == "bleu":
+            results.update(compute_bleu(hypotheses, references))
+        elif metric == "comet":
+            results.update(compute_comet(sources, hypotheses, references))
+        elif metric == "chrf":
+            results.update(compute_chrf(hypotheses, references))
+        elif metric == "ter":
+            results.update(compute_ter(hypotheses, references))
+        else:
+            logger.warning("Unsupported evaluation metric: %s", metric)
+        elapsed = time.time() - start_time
+        logger.info("Computed %s in %.2f seconds", metric, elapsed)
+
+    return results