Upload 4 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 gensan.pdf filter=lfs diff=lfs merge=lfs -text
+gensan.xlsx filter=lfs diff=lfs merge=lfs -text

gensan.xlsx

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

name_address_pred/inference.py

@@ -0,0 +1,133 @@
+"""
+===============================================================================
+推論スクリプト
+学習済みモデルを使って、テキストから国名・タイプを予測する
+===============================================================================
+"""
+
+import json
+import torch
+import torch.nn as nn
+from transformers import XLMRobertaTokenizer, XLMRobertaModel
+
+
+# --- Model定義（train_pipeline.py と同一） ---
+class MultiTaskClassifier(nn.Module):
+    def __init__(self, model_name, num_countries, dropout=0.3):
+        super().__init__()
+        self.xlmr = XLMRobertaModel.from_pretrained(model_name)
+        hidden_size = self.xlmr.config.hidden_size
+        self.shared_layer = nn.Sequential(
+            nn.Linear(hidden_size, 512),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+        )
+        self.country_head = nn.Linear(512, num_countries)
+        self.type_head = nn.Linear(512, 1)
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.xlmr(input_ids=input_ids, attention_mask=attention_mask)
+        cls_output = outputs.last_hidden_state[:, 0, :]
+        shared = self.shared_layer(cls_output)
+        return self.country_head(shared), self.type_head(shared).squeeze(-1)
+
+
+class Predictor:
+    def __init__(
+        self,
+        model_path="output/best_model.pt",
+        encoder_path="output/country_encoder.json",
+        model_name="xlm-roberta-base",
+        device=None,
+    ):
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        # Country encoder
+        with open(encoder_path, "r", encoding="utf-8") as f:
+            self.classes = json.load(f)["classes"]
+        self.num_countries = len(self.classes)
+
+        # Tokenizer
+        self.tokenizer = XLMRobertaTokenizer.from_pretrained(model_name)
+
+        # Model
+        self.model = MultiTaskClassifier(model_name, self.num_countries).to(self.device)
+        checkpoint = torch.load(model_path, map_location=self.device)
+        self.model.load_state_dict(checkpoint["model_state_dict"])
+        self.model.eval()
+
+    @torch.no_grad()
+    def predict(self, texts: list[str], top_k: int = 3) -> list[dict]:
+        """
+        テキストのリストを受け取り、各テキストの予測結果を返す
+
+        Returns:
+            list of dict:
+                - type: "name" or "address"
+                - type_confidence: float
+                - top_countries: list of (country, probability)
+        """
+        encoding = self.tokenizer(
+            texts,
+            max_length=128,
+            padding=True,
+            truncation=True,
+            return_tensors="pt",
+        )
+        input_ids = encoding["input_ids"].to(self.device)
+        attention_mask = encoding["attention_mask"].to(self.device)
+
+        country_logits, type_logit = self.model(input_ids, attention_mask)
+
+        # Country probabilities
+        country_probs = torch.softmax(country_logits, dim=1).cpu().numpy()
+        # Type probabilities
+        type_probs = torch.sigmoid(type_logit).cpu().numpy()
+
+        results = []
+        for i in range(len(texts)):
+            # Top-K countries
+            top_indices = country_probs[i].argsort()[::-1][:top_k]
+            top_countries = [
+                {"country": self.classes[idx], "probability": float(country_probs[i][idx])}
+                for idx in top_indices
+            ]
+
+            # Type
+            t_prob = float(type_probs[i])
+            text_type = "address" if t_prob > 0.5 else "name"
+
+            results.append({
+                "input": texts[i],
+                "type": text_type,
+                "type_confidence": t_prob if text_type == "address" else 1 - t_prob,
+                "top_countries": top_countries,
+            })
+
+        return results
+
+
+# =============================================================================
+# 使用例
+# =============================================================================
+if __name__ == "__main__":
+    predictor = Predictor()
+
+    test_texts = [
+        "田中太郎",
+        "東京都渋谷区神宮前1-2-3",
+        "John Smith",
+        "1600 Pennsylvania Avenue NW, Washington, DC",
+        "محمد أحمد",
+        "Müller",
+        "Via Roma 15, 00100 Roma",
+    ]
+
+    results = predictor.predict(test_texts, top_k=5)
+
+    for r in results:
+        print(f"\nInput: {r['input']}")
+        print(f"  Type: {r['type']} (confidence: {r['type_confidence']:.3f})")
+        print(f"  Top countries:")
+        for c in r["top_countries"]:
+            print(f"    {c['country']}: {c['probability']:.4f}")

name_address_pred/requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.0.0
+transformers>=4.30.0
+scikit-learn>=1.3.0
+pandas>=2.0.0
+tqdm>=4.65.0

name_address_pred/train_pipeline.py

@@ -0,0 +1,522 @@
+"""
+===============================================================================
+XLM-RoBERTa Multi-Task Classification Pipeline
+- Task 1: Country prediction (multi-class)
+- Task 2: Name/Address type prediction (binary)
+===============================================================================
+"""
+
+import os
+import random
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
+from transformers import XLMRobertaTokenizer, XLMRobertaModel
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import classification_report, accuracy_score, f1_score
+from collections import Counter
+from tqdm import tqdm
+import json
+import logging
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# 0. Config
+# =============================================================================
+class Config:
+    # Paths
+    DATA_PATH = "data.csv"                  # 入力CSVのパス（text, country, label）
+    OUTPUT_DIR = "output"                    # モデル・結果の保存先
+    MODEL_NAME = "xlm-roberta-base"         # HuggingFace モデル名
+
+    # Data split
+    TEST_SIZE = 0.15
+    VAL_SIZE = 0.10                         # train全体に対する割合
+    RANDOM_SEED = 42
+
+    # Training
+    MAX_LENGTH = 128                        # トークン最大長
+    BATCH_SIZE = 64
+    NUM_EPOCHS = 5
+    LEARNING_RATE = 2e-5
+    WEIGHT_DECAY = 0.01
+    WARMUP_RATIO = 0.1
+    MAX_GRAD_NORM = 1.0
+
+    # Loss
+    TYPE_LOSS_WEIGHT = 0.3                  # 2値分類lossの重み（メインは国分類）
+    CLASS_WEIGHT_CLAMP = 50.0               # 少数クラスの重み上限
+
+    # XLM-R fine-tuning
+    FREEZE_EMBEDDINGS = True                # embedding層をfreezeして学習安定化
+    FREEZE_LOWER_LAYERS = 0                 # 下位N層をfreeze (0=全層学習)
+
+    # Device
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+# =============================================================================
+# 1. Data Preparation
+# =============================================================================
+def load_and_split_data(cfg: Config):
+    """CSVを読み込み、ラベルエンコード、train/val/test分割を行う"""
+
+    logger.info(f"Loading data from {cfg.DATA_PATH}")
+    df = pd.read_csv(cfg.DATA_PATH)
+    logger.info(f"Total samples: {len(df)}")
+
+    # --- ラベルエンコード ---
+    # Country → integer
+    country_encoder = LabelEncoder()
+    df["country_id"] = country_encoder.fit_transform(df["country"])
+    num_countries = len(country_encoder.classes_)
+    logger.info(f"Number of countries: {num_countries}")
+
+    # Label (name/address) → binary
+    label_map = {"name": 0, "address": 1}
+    df["type_id"] = df["label"].map(label_map)
+
+    # --- 分布の確認 ---
+    country_counts = df["country"].value_counts()
+    logger.info(f"Country distribution (top 10):\n{country_counts.head(10)}")
+    logger.info(f"Country distribution (bottom 10):\n{country_counts.tail(10)}")
+    logger.info(f"Type distribution:\n{df['label'].value_counts()}")
+
+    # --- Stratified Split ---
+    # まず test を分離（country で層化）
+    train_val_df, test_df = train_test_split(
+        df,
+        test_size=cfg.TEST_SIZE,
+        random_state=cfg.RANDOM_SEED,
+        stratify=df["country_id"],
+    )
+
+    # 次に train と val を分離
+    relative_val_size = cfg.VAL_SIZE / (1 - cfg.TEST_SIZE)
+    train_df, val_df = train_test_split(
+        train_val_df,
+        test_size=relative_val_size,
+        random_state=cfg.RANDOM_SEED,
+        stratify=train_val_df["country_id"],
+    )
+
+    train_df = train_df.reset_index(drop=True)
+    val_df = val_df.reset_index(drop=True)
+    test_df = test_df.reset_index(drop=True)
+
+    logger.info(f"Split sizes - Train: {len(train_df)}, Val: {len(val_df)}, Test: {len(test_df)}")
+
+    return train_df, val_df, test_df, country_encoder, num_countries
+
+
+# =============================================================================
+# 2. Dataset
+# =============================================================================
+class TextClassificationDataset(Dataset):
+    def __init__(self, df, tokenizer, max_length):
+        self.texts = df["text"].tolist()
+        self.country_ids = df["country_id"].tolist()
+        self.type_ids = df["type_id"].tolist()
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        text = str(self.texts[idx])
+        encoding = self.tokenizer(
+            text,
+            max_length=self.max_length,
+            padding="max_length",
+            truncation=True,
+            return_tensors="pt",
+        )
+        return {
+            "input_ids": encoding["input_ids"].squeeze(0),
+            "attention_mask": encoding["attention_mask"].squeeze(0),
+            "country_id": torch.tensor(self.country_ids[idx], dtype=torch.long),
+            "type_id": torch.tensor(self.type_ids[idx], dtype=torch.float),
+        }
+
+
+# =============================================================================
+# 3. Model
+# =============================================================================
+class MultiTaskClassifier(nn.Module):
+    def __init__(self, model_name, num_countries, dropout=0.3):
+        super().__init__()
+        self.xlmr = XLMRobertaModel.from_pretrained(model_name)
+        hidden_size = self.xlmr.config.hidden_size  # 768
+
+        self.shared_layer = nn.Sequential(
+            nn.Linear(hidden_size, 512),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+        )
+        self.country_head = nn.Linear(512, num_countries)
+        self.type_head = nn.Linear(512, 1)
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.xlmr(input_ids=input_ids, attention_mask=attention_mask)
+        cls_output = outputs.last_hidden_state[:, 0, :]  # [CLS] token
+
+        shared = self.shared_layer(cls_output)
+        country_logits = self.country_head(shared)
+        type_logit = self.type_head(shared).squeeze(-1)
+
+        return country_logits, type_logit
+
+    def freeze_embeddings(self):
+        """Embedding層をフリーズ"""
+        for param in self.xlmr.embeddings.parameters():
+            param.requires_grad = False
+        logger.info("Froze XLM-R embedding layer")
+
+    def freeze_lower_layers(self, num_layers):
+        """下位N層をフリーズ"""
+        if num_layers <= 0:
+            return
+        for i in range(num_layers):
+            for param in self.xlmr.encoder.layer[i].parameters():
+                param.requires_grad = False
+        logger.info(f"Froze lower {num_layers} transformer layers")
+
+
+# =============================================================================
+# 4. Loss
+# =============================================================================
+class MultiTaskLoss(nn.Module):
+    def __init__(self, country_weights, type_loss_weight=0.3):
+        super().__init__()
+        self.country_loss_fn = nn.CrossEntropyLoss(weight=country_weights)
+        self.type_loss_fn = nn.BCEWithLogitsLoss()
+        self.type_loss_weight = type_loss_weight
+
+    def forward(self, country_logits, type_logit, country_label, type_label):
+        loss_country = self.country_loss_fn(country_logits, country_label)
+        loss_type = self.type_loss_fn(type_logit, type_label)
+        total_loss = loss_country + self.type_loss_weight * loss_type
+
+        return total_loss, loss_country.item(), loss_type.item()
+
+
+def compute_class_weights(train_df, num_countries, clamp_max=50.0):
+    """Inverse frequency weight を計算"""
+    counts = Counter(train_df["country_id"].tolist())
+    total = len(train_df)
+    weights = torch.zeros(num_countries)
+    for cls_id in range(num_countries):
+        count = counts.get(cls_id, 1)
+        weights[cls_id] = total / (num_countries * count)
+    weights = weights.clamp(max=clamp_max)
+    logger.info(f"Class weights range: [{weights.min():.2f}, {weights.max():.2f}]")
+    return weights
+
+
+# =============================================================================
+# 5. Sampler (Optional: WeightedRandomSampler)
+# =============================================================================
+def create_weighted_sampler(train_df):
+    """少数クラスをオーバーサンプリングするサンプラーを作成"""
+    counts = Counter(train_df["country_id"].tolist())
+    sample_weights = [1.0 / counts[cid] for cid in train_df["country_id"]]
+    sampler = WeightedRandomSampler(
+        weights=sample_weights,
+        num_samples=len(train_df),
+        replacement=True,
+    )
+    return sampler
+
+
+# =============================================================================
+# 6. Training Loop
+# =============================================================================
+def train_one_epoch(model, dataloader, loss_fn, optimizer, scheduler, cfg):
+    model.train()
+    total_loss = 0
+    total_country_loss = 0
+    total_type_loss = 0
+    all_country_preds = []
+    all_country_labels = []
+
+    pbar = tqdm(dataloader, desc="Training", leave=False)
+    for batch in pbar:
+        input_ids = batch["input_ids"].to(cfg.DEVICE)
+        attention_mask = batch["attention_mask"].to(cfg.DEVICE)
+        country_labels = batch["country_id"].to(cfg.DEVICE)
+        type_labels = batch["type_id"].to(cfg.DEVICE)
+
+        optimizer.zero_grad()
+        country_logits, type_logit = model(input_ids, attention_mask)
+        loss, l_country, l_type = loss_fn(country_logits, type_logit, country_labels, type_labels)
+
+        loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), cfg.MAX_GRAD_NORM)
+        optimizer.step()
+        scheduler.step()
+
+        total_loss += loss.item()
+        total_country_loss += l_country
+        total_type_loss += l_type
+
+        preds = country_logits.argmax(dim=1).cpu().numpy()
+        all_country_preds.extend(preds)
+        all_country_labels.extend(country_labels.cpu().numpy())
+
+        pbar.set_postfix(loss=f"{loss.item():.4f}")
+
+    n = len(dataloader)
+    acc = accuracy_score(all_country_labels, all_country_preds)
+    return {
+        "loss": total_loss / n,
+        "country_loss": total_country_loss / n,
+        "type_loss": total_type_loss / n,
+        "country_acc": acc,
+    }
+
+
+@torch.no_grad()
+def evaluate(model, dataloader, loss_fn, cfg):
+    model.eval()
+    total_loss = 0
+    total_country_loss = 0
+    total_type_loss = 0
+    all_country_preds = []
+    all_country_labels = []
+    all_type_preds = []
+    all_type_labels = []
+
+    for batch in tqdm(dataloader, desc="Evaluating", leave=False):
+        input_ids = batch["input_ids"].to(cfg.DEVICE)
+        attention_mask = batch["attention_mask"].to(cfg.DEVICE)
+        country_labels = batch["country_id"].to(cfg.DEVICE)
+        type_labels = batch["type_id"].to(cfg.DEVICE)
+
+        country_logits, type_logit = model(input_ids, attention_mask)
+        loss, l_country, l_type = loss_fn(country_logits, type_logit, country_labels, type_labels)
+
+        total_loss += loss.item()
+        total_country_loss += l_country
+        total_type_loss += l_type
+
+        all_country_preds.extend(country_logits.argmax(dim=1).cpu().numpy())
+        all_country_labels.extend(country_labels.cpu().numpy())
+        all_type_preds.extend((torch.sigmoid(type_logit) > 0.5).int().cpu().numpy())
+        all_type_labels.extend(type_labels.int().cpu().numpy())
+
+    n = len(dataloader)
+    country_acc = accuracy_score(all_country_labels, all_country_preds)
+    country_f1_macro = f1_score(all_country_labels, all_country_preds, average="macro", zero_division=0)
+    country_f1_weighted = f1_score(all_country_labels, all_country_preds, average="weighted", zero_division=0)
+    type_acc = accuracy_score(all_type_labels, all_type_preds)
+    type_f1 = f1_score(all_type_labels, all_type_preds, average="binary", zero_division=0)
+
+    return {
+        "loss": total_loss / n,
+        "country_loss": total_country_loss / n,
+        "type_loss": total_type_loss / n,
+        "country_acc": country_acc,
+        "country_f1_macro": country_f1_macro,
+        "country_f1_weighted": country_f1_weighted,
+        "type_acc": type_acc,
+        "type_f1": type_f1,
+        "country_preds": all_country_preds,
+        "country_labels": all_country_labels,
+        "type_preds": all_type_preds,
+        "type_labels": all_type_labels,
+    }
+
+
+# =============================================================================
+# 7. Main
+# =============================================================================
+def main():
+    cfg = Config()
+    set_seed(cfg.RANDOM_SEED)
+    os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
+
+    # ---- Data ----
+    train_df, val_df, test_df, country_encoder, num_countries = load_and_split_data(cfg)
+
+    # エンコーダを保存（推論時に必要）
+    encoder_path = os.path.join(cfg.OUTPUT_DIR, "country_encoder.json")
+    with open(encoder_path, "w", encoding="utf-8") as f:
+        json.dump(
+            {"classes": country_encoder.classes_.tolist()},
+            f,
+            ensure_ascii=False,
+            indent=2,
+        )
+    logger.info(f"Saved country encoder to {encoder_path}")
+
+    # ---- Tokenizer & Datasets ----
+    logger.info(f"Loading tokenizer: {cfg.MODEL_NAME}")
+    tokenizer = XLMRobertaTokenizer.from_pretrained(cfg.MODEL_NAME)
+
+    train_dataset = TextClassificationDataset(train_df, tokenizer, cfg.MAX_LENGTH)
+    val_dataset = TextClassificationDataset(val_df, tokenizer, cfg.MAX_LENGTH)
+    test_dataset = TextClassificationDataset(test_df, tokenizer, cfg.MAX_LENGTH)
+
+    # ---- Sampler & DataLoader ----
+    sampler = create_weighted_sampler(train_df)
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=cfg.BATCH_SIZE,
+        sampler=sampler,
+        num_workers=4,
+        pin_memory=True,
+    )
+    val_loader = DataLoader(val_dataset, batch_size=cfg.BATCH_SIZE * 2, shuffle=False, num_workers=4, pin_memory=True)
+    test_loader = DataLoader(test_dataset, batch_size=cfg.BATCH_SIZE * 2, shuffle=False, num_workers=4, pin_memory=True)
+
+    # ---- Model ----
+    logger.info("Building model")
+    model = MultiTaskClassifier(cfg.MODEL_NAME, num_countries).to(cfg.DEVICE)
+
+    if cfg.FREEZE_EMBEDDINGS:
+        model.freeze_embeddings()
+    if cfg.FREEZE_LOWER_LAYERS > 0:
+        model.freeze_lower_layers(cfg.FREEZE_LOWER_LAYERS)
+
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    total_params = sum(p.numel() for p in model.parameters())
+    logger.info(f"Parameters: {trainable_params:,} trainable / {total_params:,} total")
+
+    # ---- Loss ----
+    country_weights = compute_class_weights(train_df, num_countries, cfg.CLASS_WEIGHT_CLAMP).to(cfg.DEVICE)
+    loss_fn = MultiTaskLoss(country_weights, type_loss_weight=cfg.TYPE_LOSS_WEIGHT)
+
+    # ---- Optimizer & Scheduler ----
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=cfg.LEARNING_RATE,
+        weight_decay=cfg.WEIGHT_DECAY,
+    )
+    total_steps = len(train_loader) * cfg.NUM_EPOCHS
+    warmup_steps = int(total_steps * cfg.WARMUP_RATIO)
+
+    scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer,
+        max_lr=cfg.LEARNING_RATE,
+        total_steps=total_steps,
+        pct_start=cfg.WARMUP_RATIO,
+        anneal_strategy="cos",
+    )
+
+    # ---- Training ----
+    best_val_f1 = 0.0
+    history = []
+
+    for epoch in range(1, cfg.NUM_EPOCHS + 1):
+        logger.info(f"\n{'='*60}")
+        logger.info(f"Epoch {epoch}/{cfg.NUM_EPOCHS}")
+        logger.info(f"{'='*60}")
+
+        train_metrics = train_one_epoch(model, train_loader, loss_fn, optimizer, scheduler, cfg)
+        logger.info(
+            f"[Train] Loss: {train_metrics['loss']:.4f} | "
+            f"Country Loss: {train_metrics['country_loss']:.4f} | "
+            f"Type Loss: {train_metrics['type_loss']:.4f} | "
+            f"Country Acc: {train_metrics['country_acc']:.4f}"
+        )
+
+        val_metrics = evaluate(model, val_loader, loss_fn, cfg)
+        logger.info(
+            f"[Val]   Loss: {val_metrics['loss']:.4f} | "
+            f"Country Acc: {val_metrics['country_acc']:.4f} | "
+            f"Country F1(macro): {val_metrics['country_f1_macro']:.4f} | "
+            f"Country F1(weighted): {val_metrics['country_f1_weighted']:.4f} | "
+            f"Type Acc: {val_metrics['type_acc']:.4f}"
+        )
+
+        history.append({
+            "epoch": epoch,
+            "train_loss": train_metrics["loss"],
+            "val_loss": val_metrics["loss"],
+            "val_country_acc": val_metrics["country_acc"],
+            "val_country_f1_macro": val_metrics["country_f1_macro"],
+            "val_country_f1_weighted": val_metrics["country_f1_weighted"],
+            "val_type_acc": val_metrics["type_acc"],
+            "val_type_f1": val_metrics["type_f1"],
+        })
+
+        # Best model の保存（macro F1 基準）
+        if val_metrics["country_f1_macro"] > best_val_f1:
+            best_val_f1 = val_metrics["country_f1_macro"]
+            save_path = os.path.join(cfg.OUTPUT_DIR, "best_model.pt")
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "val_f1_macro": best_val_f1,
+                "num_countries": num_countries,
+            }, save_path)
+            logger.info(f"*** New best model saved (F1 macro: {best_val_f1:.4f}) ***")
+
+    # ---- 学習履歴の保存 ----
+    history_path = os.path.join(cfg.OUTPUT_DIR, "training_history.json")
+    with open(history_path, "w") as f:
+        json.dump(history, f, indent=2)
+
+    # ---- Test Evaluation ----
+    logger.info(f"\n{'='*60}")
+    logger.info("Final Evaluation on Test Set")
+    logger.info(f"{'='*60}")
+
+    # ベストモデルをロード
+    checkpoint = torch.load(os.path.join(cfg.OUTPUT_DIR, "best_model.pt"), map_location=cfg.DEVICE)
+    model.load_state_dict(checkpoint["model_state_dict"])
+    logger.info(f"Loaded best model from epoch {checkpoint['epoch']}")
+
+    test_metrics = evaluate(model, test_loader, loss_fn, cfg)
+
+    logger.info(f"\n--- Country Classification ---")
+    logger.info(f"Accuracy:          {test_metrics['country_acc']:.4f}")
+    logger.info(f"F1 (macro):        {test_metrics['country_f1_macro']:.4f}")
+    logger.info(f"F1 (weighted):     {test_metrics['country_f1_weighted']:.4f}")
+    logger.info(f"\n--- Type Classification (Name/Address) ---")
+    logger.info(f"Accuracy:          {test_metrics['type_acc']:.4f}")
+    logger.info(f"F1:                {test_metrics['type_f1']:.4f}")
+
+    # 詳細レポート
+    report = classification_report(
+        test_metrics["country_labels"],
+        test_metrics["country_preds"],
+        target_names=country_encoder.classes_,
+        output_dict=True,
+        zero_division=0,
+    )
+    report_path = os.path.join(cfg.OUTPUT_DIR, "test_classification_report.json")
+    with open(report_path, "w", encoding="utf-8") as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+    logger.info(f"Saved detailed report to {report_path}")
+
+    # テキスト版レポートも表示
+    print("\n" + classification_report(
+        test_metrics["country_labels"],
+        test_metrics["country_preds"],
+        target_names=country_encoder.classes_,
+        zero_division=0,
+    ))
+
+    logger.info("Done!")
+
+
+if __name__ == "__main__":
+    main()