Upload rft_v2

rft_v2/topo_config_v2.yaml

@@ -0,0 +1,142 @@
+# ============================================================================
+# Topological Error Detection RL Training Config v2
+# ============================================================================
+#
+# Key changes vs. topo_config_extended.yaml (v4):
+#   - Hungarian optimal matching replaces window-based matching
+#   - F1-based detection reward replaces decoupled type/position + count penalty
+#   - Removed: Adaptive Count Penalty, Dynamic Window Size,
+#              Complexity-Aware Weighting, scoring_method, window_size, etc.
+#   - Reward function: topo_reward_hungarian.py:compute_score
+# ============================================================================
+
+data:
+  train_files: /data/meilong/projects/topoagent/data_v2_fixed/final_json/rl_train_all_w_skeletons_cleaned_cov80.json
+  val_files: /data/meilong/projects/topoagent/data_v2/RL_data/rl_val_all.json
+  prompt_key: problem
+  answer_key: answer
+  image_key: images
+  video_key: videos
+  image_dir: null
+  video_fps: 2.0
+  max_prompt_length: 2048
+  max_response_length: 2048
+  rollout_batch_size: 256
+  mini_rollout_batch_size: null
+  val_batch_size: 512
+  format_prompt: ./topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_prompt.jinja
+  override_chat_template: null
+  shuffle: true
+  seed: 42
+  min_pixels: 65536
+  max_pixels: 524288
+  filter_overlong_prompts: true
+
+algorithm:
+  adv_estimator: grpo
+  disable_kl: false
+  use_kl_loss: true
+  kl_penalty: low_var_kl
+  kl_coef: 0.05
+  online_filtering: false
+  filter_key: overall
+  filter_low: 0.01
+  filter_high: 0.99
+
+worker:
+  actor:
+    global_batch_size: 64
+    micro_batch_size_per_device_for_update: 1
+    micro_batch_size_per_device_for_experience: 2
+    max_grad_norm: 1.0
+    padding_free: true
+    dynamic_batching: true
+    ulysses_size: 1
+    model:
+      model_path: /data/meilong/projects/topoagent/trained_models/sft/roads/qwen3-vl-4b-instruct/roads_sft_4b_20260201_015911
+      enable_gradient_checkpointing: true
+      trust_remote_code: false
+      freeze_vision_tower: false
+    optim:
+      lr: 5.0e-7
+      weight_decay: 1.0e-2
+      strategy: adamw
+      lr_warmup_ratio: 0.1
+    fsdp:
+      enable_full_shard: true
+      enable_cpu_offload: false
+      enable_rank0_init: true
+    offload:
+      offload_params: true
+      offload_optimizer: true
+
+  rollout:
+    n: 4
+    temperature: 0.8
+    top_p: 0.95
+    limit_images: 0
+    gpu_memory_utilization: 0.7
+    enforce_eager: true
+    enable_chunked_prefill: false
+    tensor_parallel_size: 1
+    disable_tqdm: false
+    val_override_config:
+      temperature: 0.6
+      top_p: 0.95
+      n: 1
+
+  ref:
+    fsdp:
+      enable_full_shard: true
+      enable_cpu_offload: true
+      enable_rank0_init: true
+    offload:
+      offload_params: false
+
+  reward:
+    reward_function: /data/meilong/projects/topoagent/src/EasyR1/topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_reward_hungarian.py:compute_score
+    reward_function_kwargs:
+      # ==================================================================
+      # v2 Reward Weights (Hungarian + F1)
+      # ==================================================================
+      # Top-level: format / accuracy / cldice
+      format_weight: 0.10
+      accuracy_weight: 0.85
+      cldice_weight: 0.05
+
+      # Accuracy sub-weights (inside R_accuracy)
+      detection_weight: 0.60        # F1-based detection score
+      localization_weight: 0.25     # IoU quality of matched pairs
+      type_bonus_weight: 0.15       # match count / max(n_gt, n_pred)
+
+      # IoU → score mapping (smooth tiered)
+      iou_thresholds: [0.3, 0.5, 0.7, 0.9]
+      iou_rewards: [0.25, 0.55, 0.8, 1.0]
+      smooth_power: 1.5
+
+      # Hungarian matching IoU threshold
+      match_iou_threshold: 0.1
+
+      # clDice parameters
+      cldice_size_threshold: 0.3
+      cldice_penalty_scale: 0.8
+
+trainer:
+  total_epochs: 10
+  max_steps: null
+  project_name: topoagent_rl
+  experiment_name: qwen3_vl_4b_rft_v2
+  logger: ["file", "wandb", "tensorboard"]
+  nnodes: 1
+  n_gpus_per_node: 8
+  max_try_make_batch: 20
+  val_freq: 2
+  val_before_train: true
+  val_only: false
+  val_generations_to_log: 5
+  save_freq: 2
+  save_limit: 5
+  save_model_only: false
+  save_checkpoint_path: /data/meilong/projects/topoagent/trained_models/rft/data_v2
+  load_checkpoint_path: null
+  find_last_checkpoint: true

rft_v2/topo_prompt.jinja

@@ -0,0 +1 @@
+{{ content | trim }}

rft_v2/topo_reward_hungarian.py

@@ -0,0 +1,508 @@
+"""
+Topological Error Detection Reward Function v2 — Hungarian Matching
+
+Key improvements over v1 (topo_reward_with_cldice.py):
+  1. Hungarian optimal matching replaces window-based matching
+     - Each GT error matched at most once (no duplicate matching)
+     - Global optimum, order-independent
+  2. F1-based detection reward replaces averaging over predictions
+     - Naturally penalises both false positives and false negatives
+     - Aligned with evaluation metrics (evaluate_hungarian.py)
+  3. Soft IoU scoring preserves smooth gradients for RL
+  4. Removed: Adaptive Count Penalty, Dynamic Window Size,
+     Complexity-Aware Weighting (all subsumed by Hungarian + F1)
+
+Combined Reward:
+    Total = 0.10 * R_format
+          + 0.85 * R_accuracy
+          + 0.05 * R_cldice
+
+    R_accuracy = 0.60 * R_detection   (F1-based)
+               + 0.25 * R_localization (IoU quality of matched pairs)
+               + 0.15 * R_type_bonus   (type accuracy among matched pairs)
+"""
+
+import re
+import ast
+import math
+import os
+import numpy as np
+from PIL import Image
+from typing import Any, List, Dict, Tuple, Optional
+
+from scipy.optimize import linear_sum_assignment
+
+# clDice (optional — graceful fallback if unavailable)
+try:
+    import sys
+    sys.path.insert(0, "/data/meilong/projects/topoagent/src/cldice")
+    from cldice import cldice_score as _cldice_score
+    HAS_CLDICE = True
+except ImportError:
+    HAS_CLDICE = False
+
+# ============================================================================
+# Constants
+# ============================================================================
+
+REWARD_NAME = "topo_reward_hungarian_v2"
+REWARD_TYPE = "batch"
+
+VALID_ERROR_TYPES = [
+    "broken_connection",
+    "spurious_connection",
+    "missing_branch",
+    "extra_branch",
+    "erroneous_hole",
+]
+
+
+# ============================================================================
+# Parsing helpers
+# ============================================================================
+
+def extract_answer_content(response: str) -> str:
+    """Extract content inside <answer>...</answer> tags."""
+    m = re.search(r"<answer>(.*?)</answer>", response, re.DOTALL)
+    return m.group(1).strip() if m else ""
+
+
+def parse_error_list(answer_str: str) -> Optional[List[Dict[str, Any]]]:
+    """Parse error list from answer string.  Returns None on failure."""
+    try:
+        s = answer_str.strip()
+        if s == "[]":
+            return []
+        errors = ast.literal_eval(s)
+        if not isinstance(errors, list):
+            return None
+        for e in errors:
+            if not isinstance(e, dict):
+                return None
+            if "Position" not in e or "ErrorType" not in e:
+                return None
+            pos = e["Position"]
+            if not isinstance(pos, list) or len(pos) != 4:
+                return None
+            try:
+                e["Position"] = [int(c) for c in pos]
+            except (TypeError, ValueError):
+                return None
+            if e["ErrorType"] not in VALID_ERROR_TYPES:
+                return None
+        return errors
+    except Exception:
+        return None
+
+
+# ============================================================================
+# IoU helpers
+# ============================================================================
+
+def calculate_iou(b1: List[int], b2: List[int]) -> float:
+    x_left  = max(b1[0], b2[0])
+    y_top   = max(b1[1], b2[1])
+    x_right = min(b1[2], b2[2])
+    y_bot   = min(b1[3], b2[3])
+    if x_right < x_left or y_bot < y_top:
+        return 0.0
+    inter = (x_right - x_left) * (y_bot - y_top)
+    a1 = max(0, (b1[2] - b1[0]) * (b1[3] - b1[1]))
+    a2 = max(0, (b2[2] - b2[0]) * (b2[3] - b2[1]))
+    union = a1 + a2 - inter
+    return inter / union if union > 0 else 0.0
+
+
+def iou_to_score(iou: float,
+                 thresholds: List[float] = [0.3, 0.5, 0.7, 0.9],
+                 rewards: List[float] = [0.25, 0.55, 0.8, 1.0],
+                 power: float = 1.5) -> float:
+    """Smooth tiered IoU → score mapping (for continuous RL gradients)."""
+    for i, t in enumerate(thresholds):
+        if iou < t:
+            if i == 0:
+                return rewards[0] * math.pow(iou / t, power)
+            lo_t, hi_t = thresholds[i - 1], t
+            lo_r, hi_r = rewards[i - 1], rewards[i]
+            ratio = math.pow((iou - lo_t) / (hi_t - lo_t), power)
+            return lo_r + ratio * (hi_r - lo_r)
+    return rewards[-1]
+
+
+# ============================================================================
+# Hungarian matching (type-aware)
+# ============================================================================
+
+def hungarian_match_by_type(
+    gt_errors: List[Dict],
+    pred_errors: List[Dict],
+    iou_threshold: float = 0.1,
+) -> Tuple[List[Tuple[int, int, float, str]], List[int], List[int]]:
+    """
+    Type-aware Hungarian matching.
+
+    Within each error type, build an IoU cost matrix and solve the optimal
+    one-to-one assignment.  Pairs with IoU < iou_threshold are rejected.
+
+    Returns
+    -------
+    matched : list of (gt_idx, pred_idx, iou, error_type)
+    unmatched_gt : list of gt_idx
+    unmatched_pred : list of pred_idx
+    """
+    if not gt_errors and not pred_errors:
+        return [], [], []
+    if not gt_errors:
+        return [], [], list(range(len(pred_errors)))
+    if not pred_errors:
+        return [], list(range(len(gt_errors))), []
+
+    from collections import defaultdict
+    gt_by_type: Dict[str, List[Tuple[int, Dict]]] = defaultdict(list)
+    pred_by_type: Dict[str, List[Tuple[int, Dict]]] = defaultdict(list)
+    for i, e in enumerate(gt_errors):
+        gt_by_type[e["ErrorType"]].append((i, e))
+    for i, e in enumerate(pred_errors):
+        pred_by_type[e["ErrorType"]].append((i, e))
+
+    matched = []
+    matched_gt, matched_pred = set(), set()
+
+    for etype in set(list(gt_by_type) + list(pred_by_type)):
+        gts = gt_by_type.get(etype, [])
+        pds = pred_by_type.get(etype, [])
+        if not gts or not pds:
+            continue
+        iou_mat = np.zeros((len(gts), len(pds)), dtype=np.float64)
+        for i, (_, ge) in enumerate(gts):
+            for j, (_, pe) in enumerate(pds):
+                iou_mat[i, j] = calculate_iou(ge["Position"], pe["Position"])
+        row_ind, col_ind = linear_sum_assignment(-iou_mat)
+        for r, c in zip(row_ind, col_ind):
+            iou_val = float(iou_mat[r, c])
+            if iou_val >= iou_threshold:
+                gi, pi = gts[r][0], pds[c][0]
+                matched.append((gi, pi, iou_val, etype))
+                matched_gt.add(gi)
+                matched_pred.add(pi)
+
+    unmatched_gt = [i for i in range(len(gt_errors)) if i not in matched_gt]
+    unmatched_pred = [i for i in range(len(pred_errors)) if i not in matched_pred]
+    return matched, unmatched_gt, unmatched_pred
+
+
+# ============================================================================
+# Reward components
+# ============================================================================
+
+def format_reward(response: str) -> float:
+    """1.0 if the response has valid <answer> tags and parseable JSON, else 0."""
+    if "<answer>" not in response or "</answer>" not in response:
+        return 0.0
+    content = extract_answer_content(response)
+    if not content:
+        return 0.0
+    if parse_error_list(content) is None:
+        return 0.0
+    return 1.0
+
+
+def accuracy_reward(
+    response: str,
+    ground_truth: str,
+    # F1 sub-weights
+    detection_weight: float = 0.60,
+    localization_weight: float = 0.25,
+    type_bonus_weight: float = 0.15,
+    # IoU scoring params
+    iou_thresholds: List[float] = [0.3, 0.5, 0.7, 0.9],
+    iou_rewards: List[float] = [0.25, 0.55, 0.8, 1.0],
+    smooth_power: float = 1.5,
+    # Hungarian matching
+    match_iou_threshold: float = 0.1,
+) -> Tuple[float, Dict[str, Any]]:
+    """
+    Accuracy reward based on Hungarian matching and soft-F1.
+
+    R_accuracy = w_det * R_detection
+               + w_loc * R_localization
+               + w_type * R_type_bonus
+    """
+    # --- parse ---
+    pred_content = extract_answer_content(response)
+    pred_errors = parse_error_list(pred_content)
+    if pred_errors is None:
+        return 0.0, {"reason": "parse_failure"}
+
+    gt_str = extract_answer_content(ground_truth) if "<answer>" in ground_truth else ground_truth
+    gt_errors = parse_error_list(gt_str)
+    if gt_errors is None:
+        return 0.0, {"reason": "gt_parse_failure"}
+
+    n_gt = len(gt_errors)
+    n_pred = len(pred_errors)
+
+    # --- both empty (correct negative) ---
+    if n_gt == 0 and n_pred == 0:
+        return 1.0, {"reason": "correct_negative"}
+
+    # --- one side empty ---
+    if n_gt == 0:
+        # all predictions are FP
+        return 0.0, {"reason": "false_positives", "n_fp": n_pred}
+    if n_pred == 0:
+        # all GT are FN
+        return 0.0, {"reason": "false_negatives", "n_fn": n_gt}
+
+    # --- Hungarian matching ---
+    matched, unmatched_gt, unmatched_pred = hungarian_match_by_type(
+        gt_errors, pred_errors, match_iou_threshold
+    )
+
+    # --- Soft TP: each matched pair contributes its IoU score ---
+    soft_tp = 0.0
+    matched_ious = []
+    type_correct_count = 0
+    for gt_i, pred_i, iou_val, etype in matched:
+        score = iou_to_score(iou_val, iou_thresholds, iou_rewards, smooth_power)
+        soft_tp += score
+        matched_ious.append(iou_val)
+        type_correct_count += 1  # type always correct in type-aware matching
+
+    fp = len(unmatched_pred)
+    fn = len(unmatched_gt)
+
+    # --- R_detection (soft F1) ---
+    denom = 2.0 * soft_tp + fp + fn
+    r_detection = (2.0 * soft_tp / denom) if denom > 0 else 0.0
+
+    # --- R_localization (mean IoU quality of matched pairs) ---
+    r_localization = (
+        sum(iou_to_score(iou, iou_thresholds, iou_rewards, smooth_power) for iou in matched_ious)
+        / len(matched_ious)
+    ) if matched_ious else 0.0
+
+    # --- R_type_bonus (fraction of matched pairs, always 1.0 for type-aware) ---
+    # We give bonus for having more matches relative to max(n_gt, n_pred)
+    r_type_bonus = len(matched) / max(n_gt, n_pred) if max(n_gt, n_pred) > 0 else 0.0
+
+    # --- combine ---
+    r_accuracy = (
+        detection_weight * r_detection
+        + localization_weight * r_localization
+        + type_bonus_weight * r_type_bonus
+    )
+    r_accuracy = max(0.0, min(1.0, r_accuracy))
+
+    return r_accuracy, {
+        "r_detection": r_detection,
+        "r_localization": r_localization,
+        "r_type_bonus": r_type_bonus,
+        "soft_tp": soft_tp,
+        "fp": fp,
+        "fn": fn,
+        "n_matched": len(matched),
+        "n_gt": n_gt,
+        "n_pred": n_pred,
+        "mean_iou": sum(matched_ious) / len(matched_ious) if matched_ious else 0.0,
+    }
+
+
+# ============================================================================
+# clDice reward (Hungarian-aligned)
+# ============================================================================
+
+def _crop(img: np.ndarray, bbox: List[int]) -> np.ndarray:
+    x1, y1, x2, y2 = bbox
+    x1, x2 = max(0, x1), min(img.shape[1], x2)
+    y1, y2 = max(0, y1), min(img.shape[0], y2)
+    return img[y1:y2, x1:x2] if len(img.shape) == 2 else img[y1:y2, x1:x2, :]
+
+
+def _bbox_size_ratio(bbox: List[int], img_size: int = 1000) -> float:
+    return max(0, (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])) / (img_size * img_size)
+
+
+def _loc_penalty(bbox: List[int], thresh: float = 0.5, scale: float = 0.5) -> float:
+    r = _bbox_size_ratio(bbox)
+    if r <= thresh:
+        return 1.0
+    return max(0.0, 1.0 - scale * (r - thresh) / (1.0 - thresh))
+
+
+def cldice_reward(
+    response: str,
+    ground_truth: str,
+    image_paths: List[str],
+    skeleton_paths: List[str],
+    match_iou_threshold: float = 0.1,
+    size_threshold: float = 0.5,
+    penalty_scale: float = 0.5,
+) -> Tuple[float, Dict[str, Any]]:
+    """
+    clDice reward computed only for Hungarian-matched pairs (type-aware).
+    """
+    if not HAS_CLDICE:
+        return 0.0, {"reason": "cldice_unavailable"}
+
+    pred_content = extract_answer_content(response)
+    pred_errors = parse_error_list(pred_content)
+    if not pred_errors:
+        return 0.0, {"reason": "no_predictions"}
+
+    gt_str = extract_answer_content(ground_truth) if "<answer>" in ground_truth else ground_truth
+    gt_errors = parse_error_list(gt_str)
+    if not gt_errors:
+        return 0.0, {"reason": "no_gt_errors"}
+
+    has_corrupted = len(skeleton_paths) == 2
+    if not has_corrupted:
+        return 0.0, {"reason": "no_corrupted_sample"}
+
+    seg_mask_path = image_paths[1]
+    seg_skeleton_path = skeleton_paths[0]
+    gt_skeleton_path = skeleton_paths[1]
+
+    # Find GT mask path
+    seg_dir = os.path.dirname(seg_mask_path)
+    parent_dir = os.path.dirname(seg_dir)
+    base_name = os.path.basename(seg_mask_path).replace("_corrupted.png", "").replace("_corrupted", "")
+    gt_mask_path = None
+    for p in [
+        os.path.join(parent_dir, "gt", f"{base_name}_gt.png"),
+        os.path.join(parent_dir, "label", f"{base_name}.png"),
+        seg_mask_path.replace("/corrupted/", "/gt/").replace("_corrupted", "_gt"),
+    ]:
+        if os.path.exists(p):
+            gt_mask_path = p
+            break
+    if gt_mask_path is None:
+        return 0.0, {"reason": "gt_mask_not_found"}
+
+    # Hungarian matching
+    matched, _, _ = hungarian_match_by_type(gt_errors, pred_errors, match_iou_threshold)
+    if not matched:
+        return 0.0, {"reason": "no_matched_pairs"}
+
+    # Compute clDice for each matched pair
+    rewards = []
+    try:
+        seg_mask = np.array(Image.open(seg_mask_path).convert("L"))
+        gt_mask = np.array(Image.open(gt_mask_path).convert("L"))
+    except Exception:
+        return 0.0, {"reason": "image_load_failure"}
+
+    for gt_i, pred_i, iou_val, etype in matched:
+        bbox = pred_errors[pred_i]["Position"]
+        seg_crop = _crop(seg_mask, bbox)
+        gt_crop = _crop(gt_mask, bbox)
+        if seg_crop.size == 0 or gt_crop.size == 0:
+            rewards.append(0.0)
+            continue
+        try:
+            seg_skel_crop = np.array(Image.open(seg_skeleton_path).convert("L"))
+            seg_skel_crop = _crop(seg_skel_crop, bbox)
+            gt_skel_crop = np.array(Image.open(gt_skeleton_path).convert("L"))
+            gt_skel_crop = _crop(gt_skel_crop, bbox)
+        except Exception:
+            seg_skel_crop, gt_skel_crop = None, None
+
+        try:
+            cld, _, _ = _cldice_score(
+                seg_crop, gt_crop,
+                pred_skeleton=seg_skel_crop,
+                gt_skeleton=gt_skel_crop,
+            )
+        except Exception:
+            cld = 0.0
+
+        r = (1.0 - cld) * _loc_penalty(bbox, size_threshold, penalty_scale)
+        rewards.append(r)
+
+    avg = sum(rewards) / len(rewards) if rewards else 0.0
+    return avg, {"n_matched": len(matched), "avg_cldice_reward": avg}
+
+
+# ============================================================================
+# Main entry point: compute_score  (called by verl)
+# ============================================================================
+
+def compute_score(
+    reward_inputs: List[Dict[str, Any]],
+    # Top-level weights
+    format_weight: float = 0.10,
+    accuracy_weight: float = 0.85,
+    cldice_weight: float = 0.05,
+    # Accuracy sub-weights
+    detection_weight: float = 0.60,
+    localization_weight: float = 0.25,
+    type_bonus_weight: float = 0.15,
+    # IoU scoring
+    iou_thresholds: List[float] = [0.3, 0.5, 0.7, 0.9],
+    iou_rewards: List[float] = [0.25, 0.55, 0.8, 1.0],
+    smooth_power: float = 1.5,
+    # Matching
+    match_iou_threshold: float = 0.1,
+    # clDice
+    cldice_size_threshold: float = 0.3,
+    cldice_penalty_scale: float = 0.8,
+) -> List[Dict[str, float]]:
+    """
+    Compute reward scores for a batch of samples.
+
+    Called by verl trainer as:
+        reward_function: .../topo_reward_hungarian.py:compute_score
+    """
+    # Normalise weights
+    tw = format_weight + accuracy_weight + cldice_weight
+    w_fmt = format_weight / tw
+    w_acc = accuracy_weight / tw
+    w_cld = cldice_weight / tw
+
+    scores = []
+    for inp in reward_inputs:
+        response = inp["response"]
+        ground_truth = inp["ground_truth"]
+        image_paths = inp.get("image_paths", [])
+        skeleton_paths = inp.get("skeleton_paths", [])
+
+        # 1) Format
+        s_fmt = format_reward(response)
+
+        # 2) Accuracy (Hungarian + soft-F1)
+        s_acc, _ = accuracy_reward(
+            response,
+            ground_truth,
+            detection_weight=detection_weight,
+            localization_weight=localization_weight,
+            type_bonus_weight=type_bonus_weight,
+            iou_thresholds=iou_thresholds,
+            iou_rewards=iou_rewards,
+            smooth_power=smooth_power,
+            match_iou_threshold=match_iou_threshold,
+        )
+
+        # 3) clDice
+        if skeleton_paths:
+            s_cld, _ = cldice_reward(
+                response,
+                ground_truth,
+                image_paths,
+                skeleton_paths,
+                match_iou_threshold=match_iou_threshold,
+                size_threshold=cldice_size_threshold,
+                penalty_scale=cldice_penalty_scale,
+            )
+        else:
+            s_cld = 0.0
+
+        overall = w_fmt * s_fmt + w_acc * s_acc + w_cld * s_cld
+
+        scores.append({
+            "overall": overall,
+            "format": s_fmt,
+            "accuracy": s_acc,
+            "cldice": s_cld,
+        })
+
+    return scores

rft_v2/train_qwen2.5_vl_3b.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# ============================================================================
+# RFT v2 — Qwen2.5-VL-3B  (Hungarian Matching + F1 Reward)
+# ============================================================================
+#
+# Key changes vs v4:
+#   - Hungarian optimal matching (no more window-based matching)
+#   - F1-based detection reward (no more count penalty / complexity hacks)
+#   - Aligned with evaluate_hungarian.py evaluation pipeline
+# ============================================================================
+
+set -e
+set -x
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${GREEN}============================================================================${NC}"
+echo -e "${GREEN}RFT v2 Training — Qwen2.5-VL-3B (Hungarian + F1)${NC}"
+echo -e "${GREEN}============================================================================${NC}"
+
+# ============================================================================
+# 环境设置
+# ============================================================================
+
+export WANDB_MODE=offline
+export WANDB_SILENT=true
+
+cd "$(dirname "$0")/../.." || exit 1
+echo "Working directory: $(pwd)"
+
+if [ -f "/data/meilong/projects/topoagent/.venv/bin/activate" ]; then
+    source /data/meilong/projects/topoagent/.venv/bin/activate
+fi
+
+# ============================================================================
+# 配置
+# ============================================================================
+
+PROJECT_ROOT="/data/meilong/projects/topoagent"
+MODEL_PATH="${PROJECT_ROOT}/trained_models/sft/data_v2/qwen2.5-vl-3b-instruct/data_v2_qwen2.5_sft_3b_20260207_192324"
+TRAIN_DATA="${PROJECT_ROOT}/data_v2_fixed/final_json/rl_train_all_w_skeletons_cleaned_cov80.json"
+VAL_DATA="${PROJECT_ROOT}/data_v2/RL_data/rl_val_all.json"
+CONFIG_FILE="${PROJECT_ROOT}/src/EasyR1/topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_config_v2.yaml"
+
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+BASE_SAVE_PATH="${PROJECT_ROOT}/trained_models/rft/data_v2/qwen2.5_vl_3b_v2"
+SAVE_PATH="${BASE_SAVE_PATH}/${TIMESTAMP}"
+EXPERIMENT_NAME="qwen2.5_vl_3b_rft_v2_${TIMESTAMP}"
+
+N_GPUS=8
+LOG_DIR="${SAVE_PATH}/log"
+mkdir -p "${LOG_DIR}"
+LOG_FILE="${LOG_DIR}/training.log"
+
+# ============================================================================
+# 预检查
+# ============================================================================
+
+echo -e "${YELLOW}检查配置...${NC}"
+
+for CHECK_FILE in "$CONFIG_FILE" "$TRAIN_DATA" "$VAL_DATA"; do
+    if [ ! -f "$CHECK_FILE" ]; then
+        echo -e "${RED}错误: 文件不存在: $CHECK_FILE${NC}"
+        exit 1
+    fi
+done
+
+if [ ! -d "$MODEL_PATH" ]; then
+    echo -e "${RED}错误: 模型路径不存在: $MODEL_PATH${NC}"
+    exit 1
+fi
+
+AVAILABLE_GPUS=$(nvidia-smi --query-gpu=index --format=csv,noheader | wc -l)
+echo -e "${GREEN}可用 GPU: $AVAILABLE_GPUS${NC}"
+
+if [ "$AVAILABLE_GPUS" -lt "$N_GPUS" ]; then
+    echo -e "${YELLOW}警告: 可用 GPU ($AVAILABLE_GPUS) < 配置 GPU ($N_GPUS)，自动调整${NC}"
+    N_GPUS=$AVAILABLE_GPUS
+fi
+
+mkdir -p "$SAVE_PATH"
+export TENSORBOARD_DIR="${SAVE_PATH}"
+
+# ============================================================================
+# 配置摘要
+# ============================================================================
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}Training Configuration (RFT v2)${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "Model:        ${GREEN}Qwen2.5-VL-3B-Instruct (SFT)${NC}"
+echo -e "Base Model:   ${MODEL_PATH}"
+echo -e "Config:       ${CONFIG_FILE}"
+echo -e ""
+echo -e "Reward Design (v2):"
+echo -e "  Matching:     ${YELLOW}Hungarian optimal matching${NC}"
+echo -e "  Detection:    ${YELLOW}F1-based (soft TP)${NC}"
+echo -e "  Localization: ${YELLOW}Smooth tiered IoU${NC}"
+echo -e "  Weights:      ${YELLOW}format=0.10, accuracy=0.85, cldice=0.05${NC}"
+echo -e ""
+echo -e "GPU Config:   ${N_GPUS} GPUs"
+echo -e "Save Path:    ${SAVE_PATH}"
+echo -e "TensorBoard:  ${SAVE_PATH}/tensorboard"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# ============================================================================
+# 启动训练
+# ============================================================================
+
+echo -e "${GREEN}启动训练... $(date)${NC}"
+
+python3 -m verl.trainer.main \
+    config=${CONFIG_FILE} \
+    data.train_files=${TRAIN_DATA} \
+    data.val_files=${VAL_DATA} \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    trainer.experiment_name=${EXPERIMENT_NAME} \
+    trainer.n_gpus_per_node=${N_GPUS} \
+    trainer.save_checkpoint_path=${SAVE_PATH} \
+    2>&1 | tee "${LOG_FILE}"
+
+TRAIN_EXIT_CODE=${PIPESTATUS[0]}
+
+# ============================================================================
+# 训练完成
+# ============================================================================
+
+echo ""
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}训练成功完成! $(date)${NC}"
+else
+    echo -e "${RED}训练失败 (退出代码: $TRAIN_EXIT_CODE) $(date)${NC}"
+fi
+
+echo -e "保存路径:  ${SAVE_PATH}"
+echo -e "日志文件:  ${LOG_FILE}"
+
+LATEST_LINK="${BASE_SAVE_PATH}/latest"
+rm -f "${LATEST_LINK}" 2>/dev/null
+ln -s "${TIMESTAMP}" "${LATEST_LINK}"
+
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}TensorBoard: tensorboard --logdir=${SAVE_PATH}/tensorboard${NC}"
+    exit 0
+else
+    echo -e "查看完整日志: cat ${LOG_FILE}"
+    exit 1
+fi

rft_v2/train_qwen2_vl_2b.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# ============================================================================
+# RFT v2 — Qwen2-VL-2B  (Hungarian Matching + F1 Reward)
+# ============================================================================
+#
+# Key changes vs v4:
+#   - Hungarian optimal matching (no more window-based matching)
+#   - F1-based detection reward (no more count penalty / complexity hacks)
+#   - Aligned with evaluate_hungarian.py evaluation pipeline
+# ============================================================================
+
+set -e
+set -x
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${GREEN}============================================================================${NC}"
+echo -e "${GREEN}RFT v2 Training — Qwen2-VL-2B (Hungarian + F1)${NC}"
+echo -e "${GREEN}============================================================================${NC}"
+
+# ============================================================================
+# 环境设置
+# ============================================================================
+
+export WANDB_MODE=offline
+export WANDB_SILENT=true
+
+cd "$(dirname "$0")/../.." || exit 1
+echo "Working directory: $(pwd)"
+
+if [ -f "/data/meilong/projects/topoagent/.venv/bin/activate" ]; then
+    source /data/meilong/projects/topoagent/.venv/bin/activate
+fi
+
+# ============================================================================
+# 配置
+# ============================================================================
+
+PROJECT_ROOT="/data/meilong/projects/topoagent"
+MODEL_PATH="${PROJECT_ROOT}/trained_models/sft/data_v2/qwen2-vl-2b-instruct/data_v2_qwen2_sft_2b_20260210_151807"
+TRAIN_DATA="${PROJECT_ROOT}/data_v2_fixed/final_json/rl_train_all_w_skeletons_cleaned_cov80.json"
+VAL_DATA="${PROJECT_ROOT}/data_v2/RL_data/rl_val_all.json"
+CONFIG_FILE="${PROJECT_ROOT}/src/EasyR1/topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_config_v2.yaml"
+
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+BASE_SAVE_PATH="${PROJECT_ROOT}/trained_models/rft/data_v2/qwen2_vl_2b_v2"
+SAVE_PATH="${BASE_SAVE_PATH}/${TIMESTAMP}"
+EXPERIMENT_NAME="qwen2_vl_2b_rft_v2_${TIMESTAMP}"
+
+N_GPUS=8
+LOG_DIR="${SAVE_PATH}/log"
+mkdir -p "${LOG_DIR}"
+LOG_FILE="${LOG_DIR}/training.log"
+
+# ============================================================================
+# 预检查
+# ============================================================================
+
+echo -e "${YELLOW}检查配置...${NC}"
+
+for CHECK_FILE in "$CONFIG_FILE" "$TRAIN_DATA" "$VAL_DATA"; do
+    if [ ! -f "$CHECK_FILE" ]; then
+        echo -e "${RED}错误: 文件不存在: $CHECK_FILE${NC}"
+        exit 1
+    fi
+done
+
+if [ ! -d "$MODEL_PATH" ]; then
+    echo -e "${RED}错误: 模型路径不存在: $MODEL_PATH${NC}"
+    exit 1
+fi
+
+AVAILABLE_GPUS=$(nvidia-smi --query-gpu=index --format=csv,noheader | wc -l)
+echo -e "${GREEN}可用 GPU: $AVAILABLE_GPUS${NC}"
+
+if [ "$AVAILABLE_GPUS" -lt "$N_GPUS" ]; then
+    echo -e "${YELLOW}警告: 可用 GPU ($AVAILABLE_GPUS) < 配置 GPU ($N_GPUS)，自动调整${NC}"
+    N_GPUS=$AVAILABLE_GPUS
+fi
+
+mkdir -p "$SAVE_PATH"
+export TENSORBOARD_DIR="${SAVE_PATH}"
+
+# ============================================================================
+# 配置摘要
+# ============================================================================
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}Training Configuration (RFT v2)${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "Model:        ${GREEN}Qwen2-VL-2B-Instruct (SFT)${NC}"
+echo -e "Base Model:   ${MODEL_PATH}"
+echo -e "Config:       ${CONFIG_FILE}"
+echo -e ""
+echo -e "Reward Design (v2):"
+echo -e "  Matching:     ${YELLOW}Hungarian optimal matching${NC}"
+echo -e "  Detection:    ${YELLOW}F1-based (soft TP)${NC}"
+echo -e "  Localization: ${YELLOW}Smooth tiered IoU${NC}"
+echo -e "  Weights:      ${YELLOW}format=0.10, accuracy=0.85, cldice=0.05${NC}"
+echo -e ""
+echo -e "GPU Config:   ${N_GPUS} GPUs"
+echo -e "Save Path:    ${SAVE_PATH}"
+echo -e "TensorBoard:  ${SAVE_PATH}/tensorboard"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# ============================================================================
+# 启动训练
+# ============================================================================
+
+echo -e "${GREEN}启动训练... $(date)${NC}"
+
+python3 -m verl.trainer.main \
+    config=${CONFIG_FILE} \
+    data.train_files=${TRAIN_DATA} \
+    data.val_files=${VAL_DATA} \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    trainer.experiment_name=${EXPERIMENT_NAME} \
+    trainer.n_gpus_per_node=${N_GPUS} \
+    trainer.save_checkpoint_path=${SAVE_PATH} \
+    2>&1 | tee "${LOG_FILE}"
+
+TRAIN_EXIT_CODE=${PIPESTATUS[0]}
+
+# ============================================================================
+# 训练完成
+# ============================================================================
+
+echo ""
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}训练成功完成! $(date)${NC}"
+else
+    echo -e "${RED}训练失败 (退出代码: $TRAIN_EXIT_CODE) $(date)${NC}"
+fi
+
+echo -e "保存路径:  ${SAVE_PATH}"
+echo -e "日志文件:  ${LOG_FILE}"
+
+LATEST_LINK="${BASE_SAVE_PATH}/latest"
+rm -f "${LATEST_LINK}" 2>/dev/null
+ln -s "${TIMESTAMP}" "${LATEST_LINK}"
+
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}TensorBoard: tensorboard --logdir=${SAVE_PATH}/tensorboard${NC}"
+    exit 0
+else
+    echo -e "查看完整日志: cat ${LOG_FILE}"
+    exit 1
+fi

rft_v2/train_qwen3_vl_4b.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# ============================================================================
+# RFT v2 — Qwen3-VL-4B  (Hungarian Matching + F1 Reward)
+# ============================================================================
+#
+# Key changes vs v4:
+#   - Hungarian optimal matching (no more window-based matching)
+#   - F1-based detection reward (no more count penalty / complexity hacks)
+#   - Aligned with evaluate_hungarian.py evaluation pipeline
+# ============================================================================
+
+set -e
+set -x
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${GREEN}============================================================================${NC}"
+echo -e "${GREEN}RFT v2 Training — Qwen3-VL-4B (Hungarian + F1)${NC}"
+echo -e "${GREEN}============================================================================${NC}"
+
+# ============================================================================
+# 环境设置
+# ============================================================================
+
+export WANDB_MODE=offline
+export WANDB_SILENT=true
+
+cd "$(dirname "$0")/../.." || exit 1
+echo "Working directory: $(pwd)"
+
+if [ -f "/data/meilong/projects/topoagent/.venv/bin/activate" ]; then
+    source /data/meilong/projects/topoagent/.venv/bin/activate
+fi
+
+# ============================================================================
+# 配置
+# ============================================================================
+
+PROJECT_ROOT="/data/meilong/projects/topoagent"
+MODEL_PATH="${PROJECT_ROOT}/trained_models/sft/roads/qwen3-vl-4b-instruct/roads_sft_4b_20260201_015911"
+TRAIN_DATA="${PROJECT_ROOT}/data_v2_fixed/final_json/rl_train_all_w_skeletons_cleaned_cov80.json"
+VAL_DATA="${PROJECT_ROOT}/data_v2/RL_data/rl_val_all.json"
+CONFIG_FILE="${PROJECT_ROOT}/src/EasyR1/topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_config_v2.yaml"
+
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+BASE_SAVE_PATH="${PROJECT_ROOT}/trained_models/rft/data_v2/qwen3_vl_4b_v2"
+SAVE_PATH="${BASE_SAVE_PATH}/${TIMESTAMP}"
+EXPERIMENT_NAME="qwen3_vl_4b_rft_v2_${TIMESTAMP}"
+
+N_GPUS=8
+LOG_DIR="${SAVE_PATH}/log"
+mkdir -p "${LOG_DIR}"
+LOG_FILE="${LOG_DIR}/training.log"
+
+# ============================================================================
+# 预检查
+# ============================================================================
+
+echo -e "${YELLOW}检查配置...${NC}"
+
+for CHECK_FILE in "$CONFIG_FILE" "$TRAIN_DATA" "$VAL_DATA"; do
+    if [ ! -f "$CHECK_FILE" ]; then
+        echo -e "${RED}错误: 文件不存在: $CHECK_FILE${NC}"
+        exit 1
+    fi
+done
+
+if [ ! -d "$MODEL_PATH" ]; then
+    echo -e "${RED}错误: 模型路径不存在: $MODEL_PATH${NC}"
+    exit 1
+fi
+
+AVAILABLE_GPUS=$(nvidia-smi --query-gpu=index --format=csv,noheader | wc -l)
+echo -e "${GREEN}可用 GPU: $AVAILABLE_GPUS${NC}"
+
+if [ "$AVAILABLE_GPUS" -lt "$N_GPUS" ]; then
+    echo -e "${YELLOW}警告: 可用 GPU ($AVAILABLE_GPUS) < 配置 GPU ($N_GPUS)，自动调整${NC}"
+    N_GPUS=$AVAILABLE_GPUS
+fi
+
+mkdir -p "$SAVE_PATH"
+export TENSORBOARD_DIR="${SAVE_PATH}"
+
+# ============================================================================
+# 配置摘要
+# ============================================================================
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}Training Configuration (RFT v2)${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "Model:        ${GREEN}Qwen3-VL-4B-Instruct (SFT)${NC}"
+echo -e "Base Model:   ${MODEL_PATH}"
+echo -e "Config:       ${CONFIG_FILE}"
+echo -e ""
+echo -e "Reward Design (v2):"
+echo -e "  Matching:     ${YELLOW}Hungarian optimal matching${NC}"
+echo -e "  Detection:    ${YELLOW}F1-based (soft TP)${NC}"
+echo -e "  Localization: ${YELLOW}Smooth tiered IoU${NC}"
+echo -e "  Weights:      ${YELLOW}format=0.10, accuracy=0.85, cldice=0.05${NC}"
+echo -e ""
+echo -e "GPU Config:   ${N_GPUS} GPUs"
+echo -e "Save Path:    ${SAVE_PATH}"
+echo -e "TensorBoard:  ${SAVE_PATH}/tensorboard"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# ============================================================================
+# 启动训练
+# ============================================================================
+
+echo -e "${GREEN}启动训练... $(date)${NC}"
+
+python3 -m verl.trainer.main \
+    config=${CONFIG_FILE} \
+    data.train_files=${TRAIN_DATA} \
+    data.val_files=${VAL_DATA} \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    trainer.experiment_name=${EXPERIMENT_NAME} \
+    trainer.n_gpus_per_node=${N_GPUS} \
+    trainer.save_checkpoint_path=${SAVE_PATH} \
+    2>&1 | tee "${LOG_FILE}"
+
+TRAIN_EXIT_CODE=${PIPESTATUS[0]}
+
+# ============================================================================
+# 训练完成
+# ============================================================================
+
+echo ""
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}训练成功完成! $(date)${NC}"
+else
+    echo -e "${RED}训练失败 (退出代码: $TRAIN_EXIT_CODE) $(date)${NC}"
+fi
+
+echo -e "保存路径:  ${SAVE_PATH}"
+echo -e "日志文件:  ${LOG_FILE}"
+
+LATEST_LINK="${BASE_SAVE_PATH}/latest"
+rm -f "${LATEST_LINK}" 2>/dev/null
+ln -s "${TIMESTAMP}" "${LATEST_LINK}"
+
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}TensorBoard: tensorboard --logdir=${SAVE_PATH}/tensorboard${NC}"
+    exit 0
+else
+    echo -e "查看完整日志: cat ${LOG_FILE}"
+    exit 1
+fi

rft_v2/train_qwen3_vl_8b.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# ============================================================================
+# RFT v2 — Qwen3-VL-8B  (Hungarian Matching + F1 Reward)
+# ============================================================================
+#
+# Key changes vs v4:
+#   - Hungarian optimal matching (no more window-based matching)
+#   - F1-based detection reward (no more count penalty / complexity hacks)
+#   - Aligned with evaluate_hungarian.py evaluation pipeline
+# ============================================================================
+
+set -e
+set -x
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${GREEN}============================================================================${NC}"
+echo -e "${GREEN}RFT v2 Training — Qwen3-VL-8B (Hungarian + F1)${NC}"
+echo -e "${GREEN}============================================================================${NC}"
+
+# ============================================================================
+# 环境设置
+# ============================================================================
+
+export WANDB_MODE=offline
+export WANDB_SILENT=true
+
+cd "$(dirname "$0")/../.." || exit 1
+echo "Working directory: $(pwd)"
+
+if [ -f "/data/meilong/projects/topoagent/.venv/bin/activate" ]; then
+    source /data/meilong/projects/topoagent/.venv/bin/activate
+fi
+
+# ============================================================================
+# 配置
+# ============================================================================
+
+PROJECT_ROOT="/data/meilong/projects/topoagent"
+MODEL_PATH="${PROJECT_ROOT}/trained_models/sft/data_v2/qwen3-vl-8b-instruct/data_v2_qwen3_sft_8b_20260210_232056"
+TRAIN_DATA="${PROJECT_ROOT}/data_v2_fixed/final_json/rl_train_all_w_skeletons_cleaned_cov80.json"
+VAL_DATA="${PROJECT_ROOT}/data_v2/RL_data/rl_val_all.json"
+CONFIG_FILE="${PROJECT_ROOT}/src/EasyR1/topoagent_rl_scripts/extended_dataset_scripts/rft_v2/topo_config_v2.yaml"
+
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+BASE_SAVE_PATH="${PROJECT_ROOT}/trained_models/rft/data_v2/qwen3_vl_8b_v2"
+SAVE_PATH="${BASE_SAVE_PATH}/${TIMESTAMP}"
+EXPERIMENT_NAME="qwen3_vl_8b_rft_v2_${TIMESTAMP}"
+
+N_GPUS=8
+LOG_DIR="${SAVE_PATH}/log"
+mkdir -p "${LOG_DIR}"
+LOG_FILE="${LOG_DIR}/training.log"
+
+# ============================================================================
+# 预检查
+# ============================================================================
+
+echo -e "${YELLOW}检查配置...${NC}"
+
+for CHECK_FILE in "$CONFIG_FILE" "$TRAIN_DATA" "$VAL_DATA"; do
+    if [ ! -f "$CHECK_FILE" ]; then
+        echo -e "${RED}错误: 文件不存在: $CHECK_FILE${NC}"
+        exit 1
+    fi
+done
+
+if [ ! -d "$MODEL_PATH" ]; then
+    echo -e "${RED}错误: 模型路径不存在: $MODEL_PATH${NC}"
+    exit 1
+fi
+
+AVAILABLE_GPUS=$(nvidia-smi --query-gpu=index --format=csv,noheader | wc -l)
+echo -e "${GREEN}可用 GPU: $AVAILABLE_GPUS${NC}"
+
+if [ "$AVAILABLE_GPUS" -lt "$N_GPUS" ]; then
+    echo -e "${YELLOW}警告: 可用 GPU ($AVAILABLE_GPUS) < 配置 GPU ($N_GPUS)，自动调整${NC}"
+    N_GPUS=$AVAILABLE_GPUS
+fi
+
+mkdir -p "$SAVE_PATH"
+export TENSORBOARD_DIR="${SAVE_PATH}"
+
+# ============================================================================
+# 配置摘要
+# ============================================================================
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}Training Configuration (RFT v2)${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "Model:        ${GREEN}Qwen3-VL-8B-Instruct (SFT)${NC}"
+echo -e "Base Model:   ${MODEL_PATH}"
+echo -e "Config:       ${CONFIG_FILE}"
+echo -e ""
+echo -e "Reward Design (v2):"
+echo -e "  Matching:     ${YELLOW}Hungarian optimal matching${NC}"
+echo -e "  Detection:    ${YELLOW}F1-based (soft TP)${NC}"
+echo -e "  Localization: ${YELLOW}Smooth tiered IoU${NC}"
+echo -e "  Weights:      ${YELLOW}format=0.10, accuracy=0.85, cldice=0.05${NC}"
+echo -e ""
+echo -e "GPU Config:   ${N_GPUS} GPUs"
+echo -e "Save Path:    ${SAVE_PATH}"
+echo -e "TensorBoard:  ${SAVE_PATH}/tensorboard"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# ============================================================================
+# 启动训练
+# ============================================================================
+
+echo -e "${GREEN}启动训练... $(date)${NC}"
+
+python3 -m verl.trainer.main \
+    config=${CONFIG_FILE} \
+    data.train_files=${TRAIN_DATA} \
+    data.val_files=${VAL_DATA} \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    trainer.experiment_name=${EXPERIMENT_NAME} \
+    trainer.n_gpus_per_node=${N_GPUS} \
+    trainer.save_checkpoint_path=${SAVE_PATH} \
+    2>&1 | tee "${LOG_FILE}"
+
+TRAIN_EXIT_CODE=${PIPESTATUS[0]}
+
+# ============================================================================
+# 训练完成
+# ============================================================================
+
+echo ""
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}训练成功完成! $(date)${NC}"
+else
+    echo -e "${RED}训练失败 (退出代码: $TRAIN_EXIT_CODE) $(date)${NC}"
+fi
+
+echo -e "保存路径:  ${SAVE_PATH}"
+echo -e "日志文件:  ${LOG_FILE}"
+
+LATEST_LINK="${BASE_SAVE_PATH}/latest"
+rm -f "${LATEST_LINK}" 2>/dev/null
+ln -s "${TIMESTAMP}" "${LATEST_LINK}"
+
+if [ $TRAIN_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}TensorBoard: tensorboard --logdir=${SAVE_PATH}/tensorboard${NC}"
+    exit 0
+else
+    echo -e "查看完整日志: cat ${LOG_FILE}"
+    exit 1
+fi