from __future__ import annotations import argparse import hashlib import json import sys import time import warnings from collections import defaultdict from pathlib import Path PROJECT_ROOT = Path(__file__).resolve().parents[3] SRC_ROOT = PROJECT_ROOT / "src" if str(SRC_ROOT) not in sys.path: sys.path.insert(0, str(SRC_ROOT)) import torch from torch import nn import torch.nn.functional as F from torch.utils.data import DataLoader, TensorDataset from transformers import AutoModelForImageTextToText, AutoProcessor try: from torch.utils.tensorboard import SummaryWriter except Exception: SummaryWriter = None from peft import LoraConfig, PeftModel, get_peft_model from qwen_vl_utils import process_vision_info from critic.prompts import ( build_critic_identity_prefix, build_edit_evaluator_system_prompt, build_edit_evaluator_user_prompt, ) from vlm.local_qwen import local_model_path from vlm.openrouter import extract_frames as extract_frames_jpg warnings.filterwarnings( "ignore", message=r"`torch\.cpu\.amp\.autocast\(args\.\.\.\)` is deprecated", category=FutureWarning, module=r"torch\.utils\.checkpoint", ) STAGE_ALIASES = { "evaluator_implicit_sft": "evaluator_sft", "reflector_implicit_sft": "reflection_sft", "pairwise_implicit_rm": "pairwise_rm", } STAGE_CHOICES = [ "evaluator_sft", "evaluator_implicit_sft", "evaluator_regression", "pairwise_rm", "pairwise_implicit_rm", "reflection_sft", "reflector_implicit_sft", "replay_calibration", ] STAGE_DATASET_CANDIDATES = { "evaluator_sft": ["evaluator_sft.jsonl", "evaluator_implicit_sft.jsonl", "memory_episodes.jsonl"], "evaluator_implicit_sft": ["evaluator_implicit_sft.jsonl", "memory_episodes.jsonl", "evaluator_sft.jsonl"], "evaluator_regression": ["evaluator_sft.jsonl", "evaluator_implicit_sft.jsonl", "memory_episodes.jsonl"], "pairwise_rm": ["pairwise_rm.jsonl", "pairwise_implicit_rm.jsonl", "memory_episodes.jsonl"], "pairwise_implicit_rm": ["pairwise_implicit_rm.jsonl", "memory_episodes.jsonl", "pairwise_rm.jsonl"], "reflection_sft": ["reflection_sft.jsonl", "reflector_implicit_sft.jsonl", "memory_episodes.jsonl"], "reflector_implicit_sft": ["reflector_implicit_sft.jsonl", "memory_episodes.jsonl", "reflection_sft.jsonl"], "replay_calibration": ["replay_calibration.jsonl", "memory_episodes.jsonl", "evaluator_implicit_sft.jsonl", "evaluator_sft.jsonl"], } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() parser.add_argument( "--dataset", type=Path, required=True, help=( "Training rows JSONL file, or a views directory from build_training_views.py " "(auto-resolves stage-specific dataset file)." ), ) parser.add_argument("--output-dir", type=Path, required=True) parser.add_argument("--base-model", default="qwen-vl-local-critic") parser.add_argument( "--stage", choices=STAGE_CHOICES, default="evaluator_sft", ) parser.add_argument("--max-samples", type=int, default=0) parser.add_argument("--run-smoke", action="store_true") parser.add_argument("--run-real-sft", action="store_true") parser.add_argument("--epochs", type=int, default=3) parser.add_argument("--batch-size", type=int, default=4) parser.add_argument("--lr", type=float, default=1e-3) parser.add_argument("--frames-per-video", type=int, default=2) parser.add_argument("--real-model-path", default="") parser.add_argument("--lora-r", type=int, default=8) parser.add_argument("--lora-alpha", type=int, default=16) parser.add_argument("--lora-dropout", type=float, default=0.05) parser.add_argument("--max-train-steps", type=int, default=0) parser.add_argument( "--resume-from", default="", help="Checkpoint directory to resume from, or 'latest' to use output-dir/real_sft_latest_checkpoint.txt.", ) parser.add_argument( "--init-from-checkpoint", default="", help=( "Initialize model weights from an earlier critic checkpoint without resuming optimizer/epoch state. " "Intended for cross-stage handoff such as evaluator_sft -> pairwise_rm." ), ) parser.add_argument( "--save-every-steps", type=int, default=0, help="Optionally save an intermediate checkpoint every N optimizer steps during run-real-sft.", ) parser.add_argument( "--log-every-steps", type=int, default=10, help="Print one training progress line every N optimizer steps during run-real-sft.", ) parser.add_argument( "--tensorboard", action="store_true", help="Write TensorBoard event files under output-dir/tensorboard during run-real-sft.", ) parser.add_argument( "--tensorboard-dir", default="", help="Optional TensorBoard log dir. Defaults to /tensorboard.", ) return parser.parse_args() def _canonical_stage(stage: str) -> str: return STAGE_ALIASES.get(stage, stage) def _is_implicit_stage(stage: str) -> bool: return stage in STAGE_ALIASES def _memory_required_labels() -> list[str]: return [ "history_window", "teacher_explicit_memory", "routing_target", "local_positive_teacher", "local_negative_teacher", "global_positive_teacher", "global_negative_teacher", ] def _stage_objective(stage: str) -> str: canonical = _canonical_stage(stage) if canonical == "evaluator_sft": prefix = "train memory-aware structured multi-dimensional evaluation outputs from teacher labels" if _is_implicit_stage(stage) else "train structured multi-dimensional evaluation outputs from teacher labels" return prefix if canonical == "evaluator_regression": return "train direct multi-score regression head for fast evaluator inference" if canonical == "pairwise_rm": return ( "train memory-aware relative preference judgment between candidate edited videos" if _is_implicit_stage(stage) else "train relative preference judgment between candidate edited videos" ) if canonical == "reflection_sft": return ( "train memory-aware accept/local_refine/global_replan policy from structured diagnostics" if _is_implicit_stage(stage) else "train accept/local_refine/global_replan policy from structured diagnostics" ) return "adapt critic to online replay distribution without rebuilding the base objective" def _stage_required_labels(stage: str) -> list[str]: canonical = _canonical_stage(stage) if canonical in {"evaluator_sft", "evaluator_regression"}: required = ["teacher_scores", "failure_tags", "reflection_hints"] return required + _memory_required_labels() if _is_implicit_stage(stage) else required if canonical == "pairwise_rm": required = ["candidate_a_video_path", "candidate_b_video_path", "winner", "preference_reason"] return required + _memory_required_labels() if _is_implicit_stage(stage) else required if canonical == "reflection_sft": required = ["teacher_scores", "failure_tags", "reflection_hints", "teacher_reflection_action"] return required + _memory_required_labels() if _is_implicit_stage(stage) else required return ["online_evaluation_result", "online_reflection_result"] def _stage_training_config(args: argparse.Namespace, sample_count: int) -> dict: canonical = _canonical_stage(args.stage) common = { "base_model": args.base_model, "dataset": str(args.dataset), "sample_count": sample_count, "max_samples": args.max_samples, "vision_input": { "low_frames": 3, "edited_frames": 3, "high_frames": 3, "max_total_frames": 9, }, "required_labels": _stage_required_labels(args.stage), } if _is_implicit_stage(args.stage): common["memory_context"] = { "enabled": True, "history_window_field": "history_window", "teacher_memory_field": "teacher_explicit_memory", "routing_target_field": "routing_target", "positive_negative_teacher_fields": [ "local_positive_teacher", "local_negative_teacher", "global_positive_teacher", "global_negative_teacher", ], } if canonical == "evaluator_sft": return { **common, "training_type": "supervised_finetuning", "target_format": "structured_text_or_json_scores", "vision_input": { "low_frames": 3, "edited_frames": 3, "high_frames": 0, "max_total_frames": 6, }, "losses": ["cross_entropy_on_structured_output"], "optimization": { "learning_rate": 2e-5, "weight_decay": 0.01, "warmup_ratio": 0.03, "epochs": 2, "global_batch_size": 16, }, "focus": [ "prompt_alignment", "structure_preservation", "transformation_strength", "carrier_grounding", "world_realization", "temporal_coherence", "artifact_penalty", "overall_score", ], } if canonical == "evaluator_regression": return { **common, "training_type": "direct_multimodal_regression", "target_format": "8_score_vector", "losses": ["mse_on_teacher_scores"], "optimization": { "learning_rate": 1e-4, "weight_decay": 0.01, "warmup_ratio": 0.03, "epochs": 2, "global_batch_size": 8, }, "focus": [ "fast_runtime_scoring", "prompt_alignment", "structure_preservation", "transformation_strength", "carrier_grounding", "world_realization", "temporal_coherence", "artifact_penalty", "overall_score", ], } if canonical == "pairwise_rm": return { **common, "training_type": "pairwise_reward_modeling", "target_format": "scalar_reward_difference", "losses": ["bradley_terry_pairwise_logistic"], "optimization": { "learning_rate": 1e-5, "weight_decay": 0.01, "warmup_ratio": 0.05, "epochs": 1, "global_batch_size": 8, }, "focus": [ "fine_grained_preference", "relative_quality_ranking", "closer_to_high_cost_target", ], } if canonical == "reflection_sft": return { **common, "training_type": "supervised_policy_learning", "target_format": "action_plus_patch_or_directives", "losses": ["cross_entropy_on_action_and_structured_response"], "optimization": { "learning_rate": 2e-5, "weight_decay": 0.01, "warmup_ratio": 0.03, "epochs": 2, "global_batch_size": 16, }, "focus": [ "accept_boundary", "local_refine_boundary", "global_replan_boundary", "actionable_prompt_patch", ], } return { **common, "training_type": "domain_adaptation", "target_format": "calibrated_online_judgment", "losses": ["cross_entropy", "preference_distillation"], "optimization": { "learning_rate": 5e-6, "weight_decay": 0.01, "warmup_ratio": 0.05, "epochs": 1, "global_batch_size": 8, }, "focus": [ "online_distribution_shift", "critic_calibration", "planner_edit_replay_alignment", ], } def _load_rows(path: Path, max_samples: int) -> list[dict]: rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()] if max_samples > 0: rows = rows[:max_samples] return rows def _resolve_stage_dataset_path(dataset: Path, stage: str) -> Path: path = dataset.expanduser().resolve() if path.is_file(): return path if not path.exists(): raise FileNotFoundError(f"Dataset path not found: {path}") if not path.is_dir(): raise RuntimeError(f"Dataset path must be a JSONL file or directory: {path}") candidates = list(STAGE_DATASET_CANDIDATES.get(stage, [])) if not candidates: canonical = _canonical_stage(stage) candidates = list(STAGE_DATASET_CANDIDATES.get(canonical, [])) if not candidates: candidates = [f"{stage}.jsonl"] for name in candidates: candidate_path = path / name if candidate_path.exists() and candidate_path.is_file(): return candidate_path available = sorted(item.name for item in path.glob("*.jsonl")) raise FileNotFoundError( "No stage dataset file found under " f"{path} for stage={stage}. Tried={candidates}. Available={available}" ) def _has_teacher_scores(row: dict) -> bool: return bool(row.get("teacher_scores")) def _has_teacher_signal(row: dict) -> bool: return bool( row.get("teacher_scores") or row.get("failure_tags") or row.get("reflection_hints") or row.get("teacher_reflection_action") ) def _derive_reflection_action(row: dict) -> str: if row.get("teacher_reflection_action"): return str(row["teacher_reflection_action"]) scores = row.get("teacher_scores") or {} overall = float(scores.get("overall_score", 0.0) or 0.0) if overall >= 0.8: return "accept" if overall >= 0.45: return "local_refine_prompt" return "global_replan" def _normalize_pairwise_winner(value: object) -> str: raw = str(value or "").strip().lower() mapping = { "a": "a", "candidate_a": "a", "candidate-a": "a", "left": "a", "0": "a", "b": "b", "candidate_b": "b", "candidate-b": "b", "right": "b", "1": "b", } return mapping.get(raw, "") def _is_explicit_pairwise_row(row: dict) -> bool: return bool( row.get("low_video_path") and row.get("prompt") and row.get("candidate_a_video_path") and row.get("candidate_b_video_path") and _normalize_pairwise_winner(row.get("winner")) ) def _materialize_explicit_pairwise_records(rows: list[dict]) -> list[dict]: pairwise_records: list[dict] = [] for idx, row in enumerate(rows, start=1): if not _is_explicit_pairwise_row(row): continue normalized = dict(row) normalized["pair_id"] = str(row.get("pair_id", "") or f"pairwise_explicit_{idx:04d}") normalized["pair_source_mode"] = str(row.get("pair_source_mode", "") or "explicit_pair_rows") normalized["sample_a_id"] = str( row.get("sample_a_id", "") or row.get("candidate_a_id", "") or row.get("sample_id", "") ) normalized["sample_b_id"] = str( row.get("sample_b_id", "") or row.get("candidate_b_id", "") or row.get("sample_id", "") ) normalized["candidate_a_prompt"] = str(row.get("candidate_a_prompt", "") or row.get("prompt", "") or "") normalized["candidate_b_prompt"] = str(row.get("candidate_b_prompt", "") or row.get("prompt", "") or "") normalized["candidate_a_scores"] = row.get("candidate_a_scores", {}) or {} normalized["candidate_b_scores"] = row.get("candidate_b_scores", {}) or {} normalized["winner"] = _normalize_pairwise_winner(row.get("winner")) normalized["preference_reason"] = str(row.get("preference_reason", "") or "") pairwise_records.append(normalized) return pairwise_records def _derive_pairwise_records(rows: list[dict]) -> list[dict]: rows = [row for row in rows if _has_teacher_scores(row)] grouped_prompt: dict[tuple[str, str], list[dict]] = defaultdict(list) for row in rows: key_prompt = ( str(row.get("low_video_path", "")), str(row.get("prompt", "")), ) grouped_prompt[key_prompt].append(row) pairwise_records: list[dict] = [] pair_idx = 1 def append_pairs(groups: dict, source_mode: str, start_idx: int) -> int: pair_idx_local = start_idx for _, group in groups.items(): if len(group) < 2: continue ordered = sorted( group, key=lambda item: float((item.get("teacher_scores") or {}).get("overall_score", 0.0) or 0.0), reverse=True, ) best = ordered[0] for other in ordered[1:]: best_score = float((best.get("teacher_scores") or {}).get("overall_score", 0.0) or 0.0) other_score = float((other.get("teacher_scores") or {}).get("overall_score", 0.0) or 0.0) if best_score == other_score and best.get("edited_video_path") == other.get("edited_video_path"): continue pairwise_records.append( { "pair_id": f"pairwise_{pair_idx_local:04d}", "pair_source_mode": source_mode, "sample_a_id": best.get("sample_id", ""), "sample_b_id": other.get("sample_id", ""), "low_video_path": best.get("low_video_path", ""), "high_video_path": best.get("high_video_path", ""), "prompt": best.get("prompt", ""), "candidate_a_video_path": best.get("edited_video_path", ""), "candidate_b_video_path": other.get("edited_video_path", ""), "candidate_a_prompt": best.get("prompt", ""), "candidate_b_prompt": other.get("prompt", ""), "candidate_a_scores": best.get("teacher_scores", {}), "candidate_b_scores": other.get("teacher_scores", {}), "winner": "a" if best_score >= other_score else "b", "preference_reason": ( "candidate_a has higher teacher overall_score and is treated as the stronger edited result" if best_score >= other_score else "candidate_b has higher teacher overall_score and is treated as the stronger edited result" ), } ) pair_idx_local += 1 return pair_idx_local pair_idx = append_pairs(grouped_prompt, "same_low_and_prompt", pair_idx) if pairwise_records: return pairwise_records grouped_low: dict[str, list[dict]] = defaultdict(list) for row in rows: grouped_low[str(row.get("low_video_path", ""))].append(row) pair_idx = append_pairs(grouped_low, "same_low_fallback", pair_idx) return pairwise_records def _materialize_stage_records(stage: str, rows: list[dict]) -> list[dict]: canonical = _canonical_stage(stage) if canonical in {"evaluator_sft", "evaluator_regression"}: return [ row for row in rows if row.get("low_video_path") and row.get("edited_video_path") and row.get("prompt") and row.get("teacher_scores") ] if canonical == "pairwise_rm": explicit_pairwise_rows = _materialize_explicit_pairwise_records(rows) if explicit_pairwise_rows: return explicit_pairwise_rows return _derive_pairwise_records(rows) if canonical == "reflection_sft": reflection_rows: list[dict] = [] for row in rows: if not _has_teacher_signal(row): continue if not row.get("low_video_path") or not row.get("edited_video_path") or not row.get("prompt"): continue item = dict(row) item["teacher_reflection_action"] = _derive_reflection_action(row) reflection_rows.append(item) return reflection_rows return rows def _write_jsonl(path: Path, rows: list[dict]) -> None: path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf-8") as f: for row in rows: f.write(json.dumps(row, ensure_ascii=False) + "\n") def _split_rows(rows: list[dict]) -> tuple[list[dict], list[dict]]: if not rows: return [], [] if len(rows) == 1: return rows, [] if len(rows) <= 4: return rows[:-1], rows[-1:] val_count = max(1, int(round(len(rows) * 0.2))) return rows[:-val_count], rows[-val_count:] def _format_scores_text(scores: dict) -> str: if _is_aesthetic_score_schema(scores): return _format_aesthetic_evaluator_target({"teacher_scores": scores}) return "\n".join( [ f"PROMPT_ALIGNMENT: {float(scores.get('prompt_alignment', 0.0) or 0.0):.3f}", f"STRUCTURE_PRESERVATION: {float(scores.get('structure_preservation', 0.0) or 0.0):.3f}", f"TRANSFORMATION_STRENGTH: {float(scores.get('transformation_strength', 0.0) or 0.0):.3f}", f"CARRIER_GROUNDING: {float(scores.get('carrier_grounding', 0.0) or 0.0):.3f}", f"WORLD_REALIZATION: {float(scores.get('world_realization', 0.0) or 0.0):.3f}", f"TEMPORAL_COHERENCE: {float(scores.get('temporal_coherence', 0.0) or 0.0):.3f}", f"ARTIFACT_PENALTY: {float(scores.get('artifact_penalty', 0.0) or 0.0):.3f}", f"OVERALL_SCORE: {float(scores.get('overall_score', 0.0) or 0.0):.3f}", ] ) def _is_aesthetic_score_schema(scores: dict) -> bool: return any( key in (scores or {}) for key in [ "narrative_emotional_fit", "style_world_consistency", "composition_lighting_design", "color_texture_refinement", "visual_hierarchy_readability", "overall_aesthetic_score", ] ) def _format_aesthetic_scores_text(scores: dict) -> str: return _format_aesthetic_evaluator_target({"teacher_scores": scores}) def _clamp_aesthetic_dimension_score(value: object) -> int: try: score = int(round(float(value))) except (TypeError, ValueError): score = 1 return max(1, min(4, score)) def _clamp_aesthetic_overall_score(value: object) -> float: try: score = float(value) except (TypeError, ValueError): score = 1.0 return max(1.0, min(4.0, score)) def _build_aesthetic_evaluator_system_prompt() -> str: return """You are a strict cinematic/VFX aesthetic rater. You are doing pointwise standalone aesthetic scoring: you see sampled frames from the edited video, but you do not see the source video. Use the editing instruction only as weak context for the intended visual direction. Do not judge whether the edit accurately followed the instruction, because the source video is not provided. Scoring scale for every dimension: 4 = excellent / strongly successful 3 = good with minor issues 2 = weak with clear issues 1 = failed or harms the aesthetic goal Rules: - Score each dimension independently. - There is no neutral middle score. Choose 2 or 3 when uncertain between weak and good. - If a video matches multiple descriptions, assign the lowest applicable score. - For object removal, cleanup, denoising, de-watermarking, or other utility edits, a seamless and visually natural result can be aesthetically successful even if it is not dramatic or cinematic. - Do not penalize a candidate because the requested edit removes an interesting object or makes the scene simpler. - Do not give high artistic scores just because the image is sharp or expensive-looking. - Do not give high color scores just because colors are saturated. - Penalize visible inpainting seams, visual clutter, incoherent style mixing, cheap texture/filter look, and unclear focal hierarchy when they are visible in the edited frames. - Return valid JSON only, with no markdown. """ def _infer_aesthetic_task_type(instruction: str) -> str: text = instruction.lower() if any(word in text for word in ["remove", "erase", "delete", "hide", "clean up", "de-watermark", "watermark", "logo"]): return "removal_or_cleanup" if any(word in text for word in ["add", "insert", "place", "put ", "introduce", "include"]): return "addition_or_insertion" if any(word in text for word in ["replace", "swap", "change into", "turn into", "transform", "convert"]): return "replacement_or_transformation" if any(word in text for word in ["style", "aesthetic", "cinematic", "film", "color", "lighting", "tone", "grain", "texture"]): return "style_or_look_change" if any(word in text for word in ["enhance", "restore", "sharpen", "denoise", "improve", "refine"]): return "quality_refinement" return "general_edit" def _build_aesthetic_evaluator_user_prompt(row: dict) -> str: instruction = str(row.get("prompt", "") or "") task_type = _infer_aesthetic_task_type(instruction) return f"""Editing instruction / intended effect: {instruction} Inferred task type: {task_type} Important: you do not see the source video. Do not evaluate whether the edit was completed relative to the source. Evaluate the final edited video as a standalone visual result. For removal or cleanup tasks, invisible/seamless blending is a positive aesthetic outcome. Evaluate the edited video frames on these five dimensions: 1. narrative_emotional_fit: whether the final edited result naturally integrates with the scene mood, emotional tone, and visual context without artificial or distracting anomalies. 2. style_world_consistency: whether the final visual style fits the world, era, genre, and style language such as classical, wuxia, sci-fi, realistic, fantasy, or cinematic. 3. composition_lighting_design: composition, contrast, lighting hierarchy, lens/cinematic design, and shot-level visual arrangement. 4. color_texture_refinement: color harmony, saturation control, material/texture/filter refinement, and whether it avoids cheap or generic looks. 5. visual_hierarchy_readability: whether the main visual intent is clear, focal hierarchy is readable, and important content is not obscured. "overall_aesthetic_score" should be a holistic assessment of final visual quality from 1.0 to 4.0, not a simple mathematical average of the five dimensions. Return this exact JSON schema: {{ "scores": {{ "narrative_emotional_fit": 1, "style_world_consistency": 1, "composition_lighting_design": 1, "color_texture_refinement": 1, "visual_hierarchy_readability": 1 }}, "overall_aesthetic_score": 1.0, "uncertain": false, "reason": "one concise sentence" }} """ def _format_aesthetic_evaluator_target(row: dict) -> str: scores = row.get("teacher_scores", {}) or {} raw_label = row.get("raw_label", {}) or {} hints = row.get("reflection_hints", []) or [] reason = str(raw_label.get("reason", "") or (hints[0] if hints else "") or "") payload = { "scores": { "narrative_emotional_fit": _clamp_aesthetic_dimension_score(scores.get("narrative_emotional_fit", 1)), "style_world_consistency": _clamp_aesthetic_dimension_score(scores.get("style_world_consistency", 1)), "composition_lighting_design": _clamp_aesthetic_dimension_score(scores.get("composition_lighting_design", 1)), "color_texture_refinement": _clamp_aesthetic_dimension_score(scores.get("color_texture_refinement", 1)), "visual_hierarchy_readability": _clamp_aesthetic_dimension_score(scores.get("visual_hierarchy_readability", 1)), }, "overall_aesthetic_score": _clamp_aesthetic_overall_score(scores.get("overall_aesthetic_score", raw_label.get("overall_aesthetic_score", 1.0))), "uncertain": bool(raw_label.get("uncertain", False)), "reason": reason, } return json.dumps(payload, ensure_ascii=False, indent=2) def _format_evaluator_target(row: dict) -> str: scores = row.get("teacher_scores", {}) or {} if _is_aesthetic_score_schema(scores): return _format_aesthetic_evaluator_target(row) failure_tags = row.get("failure_tags", []) or [] reflection_hints = row.get("reflection_hints", []) or [] notes = row.get("teacher_replan_directives", []) or [] return "\n".join( [ _format_scores_text(scores), "FAILURE_TAGS: " + ", ".join(str(tag) for tag in failure_tags), "REFLECTION_HINTS: " + ", ".join(str(hint) for hint in reflection_hints), "NOTES: " + ", ".join(str(item) for item in notes), ] ).strip() def _format_reflection_target(row: dict) -> str: action = str(row.get("teacher_reflection_action", "global_replan") or "global_replan") prompt_patch = row.get("teacher_prompt_patch", []) or [] replan_directives = row.get("teacher_replan_directives", []) or [] reason = "" hints = row.get("reflection_hints", []) or [] if hints: reason = str(hints[0]) elif action == "accept": reason = "Teacher judged the edit acceptable." elif action == "local_refine_prompt": reason = "Teacher judged the result directionally correct but still locally improvable." else: reason = "Teacher judged the current plan too weak and recommended replanning." return json.dumps( { "action": action, "reason": reason, "prompt_patch": prompt_patch, "replan_directives": replan_directives, }, ensure_ascii=False, ) def _coerce_optional_dict(value: object) -> dict: if isinstance(value, dict): return value if isinstance(value, str): text = value.strip() if text.startswith("{") and text.endswith("}"): try: parsed = json.loads(text) except json.JSONDecodeError: return {} if isinstance(parsed, dict): return parsed return {} def _compact_memory_history(row: dict, *, limit: int = 3) -> list[dict]: history = row.get("history_window", []) or [] compact: list[dict] = [] for item in history[:limit]: if not isinstance(item, dict): continue compact.append( { "attempt_index": int(item.get("attempt_index", 0) or 0), "overall_score": float(item.get("overall_score", 0.0) or 0.0), "action": str(item.get("action", "") or ""), "style_family": str(item.get("style_family", "") or ""), "scene_archetype": str(item.get("scene_archetype", "") or ""), "selected_strategy": str(item.get("selected_strategy", "") or ""), "primary_fx_carriers": list(item.get("primary_fx_carriers", []) or [])[:4], "failure_tags": list(item.get("failure_tags", []) or [])[:6], } ) return compact def _compact_teacher_memory(row: dict) -> dict: teacher = row.get("teacher_explicit_memory", {}) or {} if not isinstance(teacher, dict): return {} return { "scene_archetypes": list(teacher.get("scene_archetypes", []) or [])[:3], "failure_patterns": list(teacher.get("failure_patterns", []) or [])[:4], "style_convertibility_priors": list(teacher.get("style_convertibility_priors", []) or [])[:3], "prompt_compilation_recipe_candidates": list(teacher.get("prompt_compilation_recipe_candidates", []) or [])[:3], "custom_skill_records": list(teacher.get("custom_skill_records", []) or [])[:4], } def _compact_memory_side(row: dict, key: str) -> dict: payload = row.get(key, {}) or {} if not isinstance(payload, dict): return {} compact: dict[str, object] = {} for field in [ "recommended_carriers", "anchor_hints", "stable_strategies", "prompt_patch_hints", "failure_tags", "fragile_carriers", "weak_dimensions", "style_families", "archetypes", "strategies", "replan_directives", ]: value = payload.get(field) if isinstance(value, list): compact[field] = value[:6] return compact def _format_implicit_memory_context(row: dict) -> str: payload = { "routing_target": str(row.get("routing_target", "") or ""), "history_window": _compact_memory_history(row), "teacher_explicit_memory": _compact_teacher_memory(row), "local_positive_teacher": _compact_memory_side(row, "local_positive_teacher"), "local_negative_teacher": _compact_memory_side(row, "local_negative_teacher"), "global_positive_teacher": _compact_memory_side(row, "global_positive_teacher"), "global_negative_teacher": _compact_memory_side(row, "global_negative_teacher"), } return "隐式记忆教师上下文（仅供模型吸收历史信号）:\n" + json.dumps(payload, ensure_ascii=False, indent=2) def _format_user_text_for_stage(stage: str, row: dict) -> str: canonical = _canonical_stage(stage) if canonical == "evaluator_sft": scores = row.get("teacher_scores", {}) or {} if _is_aesthetic_score_schema(scores): text = _build_aesthetic_evaluator_user_prompt(row) if _is_implicit_stage(stage): text += "\n\n" + _format_implicit_memory_context(row) return text text = build_edit_evaluator_user_prompt( sample_id=str(row.get("sample_id", "") or ""), prompt=str(row.get("prompt", "") or ""), planner_summary=_coerce_optional_dict(row.get("planner_summary", {})), edit_summary=_coerce_optional_dict(row.get("edit_summary", {})), metric_hints=_coerce_optional_dict(row.get("metric_hints", {})), ) if _is_implicit_stage(stage): text += "\n\n" + _format_implicit_memory_context(row) return text if canonical == "reflection_sft": scores = row.get("teacher_scores", {}) or {} common = ( f"sample_id: {row.get('sample_id', '')}\n" f"prompt: {row.get('prompt', '')}\n" f"low_video_path: {row.get('low_video_path', '')}\n" f"edited_video_path: {row.get('edited_video_path', '')}\n" f"high_video_path: {row.get('high_video_path', '')}\n" "图片顺序如下：前半部分是 low video 抽帧，接着是 edited video 抽帧，最后是 high video 抽帧。\n" ) text = ( build_critic_identity_prefix() + "请根据已有的结构化评估结果，决定 accept、local_refine_prompt 或 global_replan。\n" + common + "已知评估分数如下：\n" + _format_scores_text(scores) + "\nfailure_tags: " + ", ".join(str(tag) for tag in (row.get("failure_tags", []) or [])) + "\nreflection_hints: " + ", ".join(str(hint) for hint in (row.get("reflection_hints", []) or [])) ) if _is_implicit_stage(stage): text += "\n" + _format_implicit_memory_context(row) return text raise ValueError(f"real SFT does not support stage={stage}") def _build_multimodal_messages(stage: str, row: dict, image_paths: list[str]) -> tuple[list[dict], str]: user_content = [{"type": "text", "text": _format_user_text_for_stage(stage, row)}] for image_path in image_paths: user_content.append({"type": "image", "image": str(image_path)}) assistant_text = _format_evaluator_target(row) if _canonical_stage(stage) == "evaluator_sft" else _format_reflection_target(row) messages: list[dict] = [] if _canonical_stage(stage) == "evaluator_sft": scores = row.get("teacher_scores", {}) or {} system_text = _build_aesthetic_evaluator_system_prompt() if _is_aesthetic_score_schema(scores) else build_edit_evaluator_system_prompt() messages.append({"role": "system", "content": [{"type": "text", "text": system_text}]}) messages.extend( [ {"role": "user", "content": user_content}, {"role": "assistant", "content": [{"type": "text", "text": assistant_text}]}, ] ) return messages, assistant_text def _build_pairwise_messages(row: dict, image_paths: list[str]) -> list[dict]: prompt = str(row.get("prompt", "") or "") preference_reason = str(row.get("preference_reason", "") or "") user_text = ( build_critic_identity_prefix() + "请比较 candidate A 和 candidate B，判断哪个 edited result 更接近目标 high-cost 结果。\n" f"prompt: {prompt}\n" f"candidate_a_prompt: {row.get('candidate_a_prompt', '')}\n" f"candidate_b_prompt: {row.get('candidate_b_prompt', '')}\n" f"preference_reason_hint: {preference_reason}\n" "图片顺序如下：先是 low video 抽帧，再是 high video 抽帧，然后是 candidate A 抽帧，最后是 candidate B 抽帧。\n" "只需要在内部判断 winner，不需要生成文本。" ) user_content = [{"type": "text", "text": user_text}] for image_path in image_paths: user_content.append({"type": "image", "image": str(image_path)}) return [{"role": "user", "content": user_content}] def _build_pairwise_reward_messages(stage: str, row: dict, *, candidate_key: str, image_paths: list[str]) -> list[dict]: prompt = str(row.get("prompt", "") or "") candidate_prompt = str(row.get(f"candidate_{candidate_key}_prompt", "") or prompt) user_text = ( build_critic_identity_prefix() + "请根据 low、high 和单个 edited candidate 的抽帧，对该 candidate 的整体质量形成内部 reward 表征。\n" f"prompt: {prompt}\n" f"candidate_prompt: {candidate_prompt}\n" "图片顺序如下：先是 low video 抽帧，再是 high video 抽帧，最后是该 edited candidate 抽帧。\n" "只需要在内部形成单个标量 reward，不需要生成文本。" ) if _is_implicit_stage(stage): user_text += "\n" + _format_implicit_memory_context(row) user_content = [{"type": "text", "text": user_text}] for image_path in image_paths: user_content.append({"type": "image", "image": str(image_path)}) return [{"role": "user", "content": user_content}] def _build_evaluator_regression_messages(row: dict, image_paths: list[str]) -> list[dict]: user_text = ( build_critic_identity_prefix() + "请根据 low video 和 edited video 的抽帧，以及目标 prompt，对编辑结果做快速多维判断。\n" f"prompt: {row.get('prompt', '')}\n" f"scene_archetype: {row.get('scene_archetype', '')}\n" f"style_family: {row.get('style_family', '')}\n" "图片顺序如下：先是 low video 抽帧，然后是 edited video 抽帧，最后是 high video 抽帧（如果存在）。\n" "内部关注维度：prompt_alignment, structure_preservation, transformation_strength, carrier_grounding, " "world_realization, temporal_coherence, artifact_penalty, overall_score。\n" "不要生成文本，只做内部表征和分数回归。" ) user_content = [{"type": "text", "text": user_text}] for image_path in image_paths: user_content.append({"type": "image", "image": str(image_path)}) return [{"role": "user", "content": user_content}] def _extract_training_frames(row: dict, frames_per_video: int, *, include_high: bool = True) -> list[str]: image_paths: list[str] = [] frame_keys = ["low_video_path", "edited_video_path"] if include_high: frame_keys.append("high_video_path") for key in frame_keys: value = str(row.get(key, "") or "").strip() if not value: continue image_paths.extend(str(p) for p in extract_frames_jpg(value, frame_count=frames_per_video)) return image_paths def _extract_aesthetic_training_frames(row: dict, frames_per_video: int) -> list[str]: value = str(row.get("edited_video_path", "") or "").strip() if not value: return [] return [str(p) for p in extract_frames_jpg(value, frame_count=frames_per_video)] def _extract_pairwise_frames(row: dict, frames_per_video: int) -> list[str]: image_paths: list[str] = [] for key in ["low_video_path", "high_video_path", "candidate_a_video_path", "candidate_b_video_path"]: value = str(row.get(key, "") or "").strip() if not value: continue image_paths.extend(str(p) for p in extract_frames_jpg(value, frame_count=frames_per_video)) return image_paths def _extract_pairwise_candidate_frames(row: dict, *, candidate_key: str, frames_per_video: int) -> list[str]: image_paths: list[str] = [] candidate_video_key = f"candidate_{candidate_key}_video_path" for key in ["low_video_path", "high_video_path", candidate_video_key]: value = str(row.get(key, "") or "").strip() if not value: continue image_paths.extend(str(p) for p in extract_frames_jpg(value, frame_count=frames_per_video)) return image_paths def _make_peft_model(model, args: argparse.Namespace): lora_config = LoraConfig( r=args.lora_r, lora_alpha=args.lora_alpha, lora_dropout=args.lora_dropout, bias="none", task_type="CAUSAL_LM", target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], ) peft_model = get_peft_model(model, lora_config) peft_model.print_trainable_parameters() return peft_model def _resolve_resume_checkpoint(output_dir: Path, resume_from: str) -> Path | None: return _resolve_checkpoint_reference( str(resume_from or "").strip(), default_output_dir=output_dir, argument_name="--resume-from", ) def _resolve_checkpoint_reference( raw_value: str, *, default_output_dir: Path | None, argument_name: str, ) -> Path | None: value = str(raw_value or "").strip() if not value: return None if value == "latest": if default_output_dir is None: raise RuntimeError(f"{argument_name}=latest requires a checkpoint output directory.") latest_pointer = default_output_dir / "real_sft_latest_checkpoint.txt" if not latest_pointer.exists(): raise FileNotFoundError(f"Latest checkpoint pointer not found: {latest_pointer}") value = latest_pointer.read_text(encoding="utf-8").strip() if not value: raise RuntimeError(f"Latest checkpoint pointer is empty: {latest_pointer}") checkpoint_dir = Path(value).expanduser() if not checkpoint_dir.exists(): raise FileNotFoundError(f"Checkpoint reference not found for {argument_name}: {checkpoint_dir}") if not checkpoint_dir.is_dir(): raise NotADirectoryError(f"Checkpoint reference for {argument_name} must be a directory: {checkpoint_dir}") if (checkpoint_dir / "trainer_state.json").exists(): return checkpoint_dir latest_pointer = checkpoint_dir / "real_sft_latest_checkpoint.txt" if latest_pointer.exists(): latest_value = latest_pointer.read_text(encoding="utf-8").strip() if not latest_value: raise RuntimeError(f"Latest checkpoint pointer is empty: {latest_pointer}") resolved = Path(latest_value).expanduser() if not resolved.exists(): raise FileNotFoundError(f"Checkpoint referenced by {latest_pointer} does not exist: {resolved}") if not resolved.is_dir(): raise NotADirectoryError(f"Checkpoint referenced by {latest_pointer} is not a directory: {resolved}") return resolved final_checkpoint = checkpoint_dir / "real_sft_checkpoint" if (final_checkpoint / "trainer_state.json").exists(): return final_checkpoint if (checkpoint_dir / "adapter_config.json").exists(): return checkpoint_dir raise FileNotFoundError( f"Could not resolve a usable checkpoint from {argument_name}={checkpoint_dir}. " "Expected a checkpoint dir, an output dir with real_sft_latest_checkpoint.txt, " "or an output dir with real_sft_checkpoint/." ) def _resolve_init_checkpoint(init_from: str) -> Path | None: return _resolve_checkpoint_reference( str(init_from or "").strip(), default_output_dir=None, argument_name="--init-from-checkpoint", ) def _load_trainer_state_if_available(checkpoint_dir: Path | None) -> dict: if checkpoint_dir is None: return {} trainer_state_path = checkpoint_dir / "trainer_state.json" if not trainer_state_path.exists(): return {} return json.loads(trainer_state_path.read_text(encoding="utf-8")) def _supports_cross_stage_init(*, target_stage: str, init_stage: str) -> bool: target_canonical = _canonical_stage(target_stage) init_canonical = _canonical_stage(init_stage) if not init_stage or init_stage == target_stage or (target_canonical == init_canonical and init_canonical): return True return target_canonical == "pairwise_rm" and init_canonical == "evaluator_sft" def _processor_source_path(*, model_path: str, checkpoint_dir: Path | None) -> str: if checkpoint_dir is None: return model_path processor_markers = [ "preprocessor_config.json", "processor_config.json", "tokenizer_config.json", ] if any((checkpoint_dir / marker).exists() for marker in processor_markers): return str(checkpoint_dir) return model_path def _checkpoint_base_model_path(checkpoint_dir: Path | None) -> str: if checkpoint_dir is None: return "" path = checkpoint_dir / "base_model_path.txt" if not path.exists(): return "" return path.read_text(encoding="utf-8").strip() def _init_metadata( *, init_checkpoint: Path | None, init_state: dict, ) -> dict: return { "init_from_checkpoint": str(init_checkpoint) if init_checkpoint is not None else "", "init_from_stage": str(init_state.get("stage", "") or ""), "init_from_model_path": _checkpoint_base_model_path(init_checkpoint), } def _effective_model_path( *, explicit_model_path: str, resume_checkpoint: Path | None, init_checkpoint: Path | None, ) -> str: if explicit_model_path: return explicit_model_path for candidate in [ _checkpoint_base_model_path(resume_checkpoint), _checkpoint_base_model_path(init_checkpoint), ]: if candidate: return candidate return str(local_model_path()) def _build_stage_mismatch_resume_error(*, resume_checkpoint: Path, expected_stage: str, actual_stage: str) -> RuntimeError: message = f"Resume checkpoint stage mismatch: expected {expected_stage}, got {actual_stage}" if _canonical_stage(expected_stage) == "pairwise_rm" and _canonical_stage(actual_stage) == "evaluator_sft": message += ( f". To start pairwise training from the evaluator critic weights, use " f"--init-from-checkpoint {resume_checkpoint} instead of --resume-from." ) return RuntimeError(message) def _optimizer_to_device(optimizer: torch.optim.Optimizer, device: torch.device) -> None: for state in optimizer.state.values(): for key, value in state.items(): if torch.is_tensor(value): state[key] = value.to(device) def _format_duration(seconds: float) -> str: total_seconds = max(0, int(round(seconds))) hours, remainder = divmod(total_seconds, 3600) minutes, secs = divmod(remainder, 60) if hours > 0: return f"{hours}h{minutes:02d}m{secs:02d}s" if minutes > 0: return f"{minutes}m{secs:02d}s" return f"{secs}s" def _run_real_sft( *, args: argparse.Namespace, stage: str, train_rows: list[dict], val_rows: list[dict], output_dir: Path, ) -> dict: canonical_stage = _canonical_stage(stage) def _match_head_input_dtype(hidden_states: torch.Tensor, head: nn.Linear) -> torch.Tensor: return hidden_states.to(device=head.weight.device, dtype=head.weight.dtype) metrics_path = output_dir / "real_sft_metrics.jsonl" if not args.resume_from or not metrics_path.exists(): metrics_path.write_text("", encoding="utf-8") checkpoint_dir = output_dir / "real_sft_checkpoint" checkpoints_root = output_dir / "real_sft_checkpoints" latest_checkpoint_path = output_dir / "real_sft_latest_checkpoint.txt" real_sft_status_path = output_dir / "real_sft_status.json" real_sft_error_path = output_dir / "real_sft_error.json" if args.resume_from and args.init_from_checkpoint: raise RuntimeError("--resume-from and --init-from-checkpoint cannot be used together.") resume_checkpoint = _resolve_resume_checkpoint(output_dir, args.resume_from) init_checkpoint = _resolve_init_checkpoint(args.init_from_checkpoint) if not train_rows: status = { "stage": stage, "status": "skipped", "reason": "no_train_samples", } real_sft_status_path.write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8") return status model = None processor = None optimizer = None pairwise_head = None evaluator_head = None summary_writer = None global_step = 0 completed_epochs = 0 start_epoch = 1 start_row_index = 0 model_path = "" init_state: dict = {} init_stage = "" try: resume_state: dict = {} init_state = _load_trainer_state_if_available(init_checkpoint) init_stage = str(init_state.get("stage", "") or "") if resume_checkpoint is not None: trainer_state_path = resume_checkpoint / "trainer_state.json" if not trainer_state_path.exists(): raise FileNotFoundError(f"trainer_state.json not found in resume checkpoint: {resume_checkpoint}") resume_state = json.loads(trainer_state_path.read_text(encoding="utf-8")) resume_stage = str(resume_state.get("stage", "") or "") if resume_stage and _canonical_stage(resume_stage) != canonical_stage: raise _build_stage_mismatch_resume_error( resume_checkpoint=resume_checkpoint, expected_stage=stage, actual_stage=resume_stage, ) if init_checkpoint is not None and not _supports_cross_stage_init(target_stage=stage, init_stage=init_stage): raise RuntimeError( f"Unsupported cross-stage initialization: target stage={stage}, init stage={init_stage or 'unknown'}" ) if init_checkpoint is not None and canonical_stage == "evaluator_regression": raise RuntimeError( "--init-from-checkpoint is not supported for evaluator_regression. " "That stage only trains a standalone fast score head; use --resume-from for same-stage continuation." ) model_path = _effective_model_path( explicit_model_path=str(args.real_model_path or "").strip(), resume_checkpoint=resume_checkpoint, init_checkpoint=init_checkpoint, ) processor_path = _processor_source_path( model_path=model_path, checkpoint_dir=resume_checkpoint or init_checkpoint, ) if args.tensorboard: if SummaryWriter is None: raise RuntimeError("TensorBoard logging requested, but torch.utils.tensorboard is unavailable.") tensorboard_dir = Path(args.tensorboard_dir).expanduser() if args.tensorboard_dir else (output_dir / "tensorboard") summary_writer = SummaryWriter(log_dir=str(tensorboard_dir)) print( ( f"[real_sft] stage={stage} train_rows={len(train_rows)} val_rows={len(val_rows)} " f"epochs={args.epochs} frames_per_video={args.frames_per_video} lr={args.lr} " f"save_every_steps={args.save_every_steps} log_every_steps={args.log_every_steps} " f"resume_from={resume_checkpoint or 'none'} init_from={init_checkpoint or 'none'} " f"init_stage={init_stage or 'unknown'} tensorboard={'on' if summary_writer is not None else 'off'}" ), flush=True, ) processor = AutoProcessor.from_pretrained(processor_path, trust_remote_code=True) model = AutoModelForImageTextToText.from_pretrained( model_path, torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, trust_remote_code=True, ) if torch.cuda.is_available(): model = model.to("cuda") if canonical_stage == "evaluator_regression": for param in model.parameters(): param.requires_grad = False model.eval() else: if hasattr(model, "gradient_checkpointing_enable"): model.gradient_checkpointing_enable() if resume_checkpoint is not None: adapter_config_path = resume_checkpoint / "adapter_config.json" if not adapter_config_path.exists(): raise FileNotFoundError( f"adapter_config.json not found in resume checkpoint: {resume_checkpoint}" ) model = PeftModel.from_pretrained(model, str(resume_checkpoint), is_trainable=True) elif init_checkpoint is not None: adapter_config_path = init_checkpoint / "adapter_config.json" if not adapter_config_path.exists(): raise FileNotFoundError( f"adapter_config.json not found in init checkpoint: {init_checkpoint}" ) model = PeftModel.from_pretrained(model, str(init_checkpoint), is_trainable=True) else: model = _make_peft_model(model, args) model.train() optimizer = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=args.lr) pairwise_criterion = None regression_criterion = None if canonical_stage == "pairwise_rm": hidden_size = getattr(getattr(model, "config", None), "hidden_size", None) if hidden_size is None: hidden_size = getattr(getattr(model, "config", None), "text_config", None) hidden_size = getattr(hidden_size, "hidden_size", None) if hidden_size is None: raise RuntimeError("Unable to infer hidden_size for pairwise reward head.") pairwise_head = nn.Linear(int(hidden_size), 1) if torch.cuda.is_available(): pairwise_head = pairwise_head.to("cuda") if resume_checkpoint is not None: reward_head_path = resume_checkpoint / "reward_head.pt" legacy_pairwise_head_path = resume_checkpoint / "pairwise_head.pt" if reward_head_path.exists(): pairwise_head.load_state_dict(torch.load(reward_head_path, map_location="cpu")) elif legacy_pairwise_head_path.exists(): raise RuntimeError( "Found legacy pairwise_head.pt in resume checkpoint, but pairwise_rm now expects reward_head.pt " "with a scalar reward head. Re-train pairwise_rm from evaluator_sft or resume from a new-format checkpoint." ) else: raise FileNotFoundError( f"reward_head.pt not found in resume checkpoint: {resume_checkpoint}" ) pairwise_head.train() pairwise_criterion = "bradley_terry_pairwise_logistic" optimizer = torch.optim.AdamW(list(model.parameters()) + list(pairwise_head.parameters()), lr=args.lr) elif canonical_stage == "evaluator_regression": hidden_size = getattr(getattr(model, "config", None), "hidden_size", None) if hidden_size is None: hidden_size = getattr(getattr(model, "config", None), "text_config", None) hidden_size = getattr(hidden_size, "hidden_size", None) if hidden_size is None: raise RuntimeError("Unable to infer hidden_size for evaluator regression head.") evaluator_head = nn.Linear(int(hidden_size), 8) if torch.cuda.is_available(): evaluator_head = evaluator_head.to("cuda") if resume_checkpoint is not None: evaluator_head_path = resume_checkpoint / "evaluator_head.pt" if not evaluator_head_path.exists(): raise FileNotFoundError(f"evaluator_head.pt not found in resume checkpoint: {resume_checkpoint}") evaluator_head.load_state_dict(torch.load(evaluator_head_path, map_location="cpu")) evaluator_head.train() regression_criterion = nn.MSELoss() optimizer = torch.optim.AdamW(list(evaluator_head.parameters()), lr=args.lr) if resume_checkpoint is not None and optimizer is not None: optimizer_state_path = resume_checkpoint / "optimizer.pt" if not optimizer_state_path.exists(): raise FileNotFoundError(f"optimizer.pt not found in resume checkpoint: {resume_checkpoint}") optimizer.load_state_dict(torch.load(optimizer_state_path, map_location="cpu")) _optimizer_to_device(optimizer, next(model.parameters()).device) if resume_state: global_step = int(resume_state.get("global_step", 0) or 0) completed_epochs = int(resume_state.get("completed_epochs", 0) or 0) start_epoch = max(1, int(resume_state.get("next_epoch", 1) or 1)) start_row_index = max(0, int(resume_state.get("next_row_index", 0) or 0)) if start_row_index >= len(train_rows): start_epoch += 1 start_row_index = 0 if start_epoch > args.epochs: status = { "stage": stage, "status": "completed", "message": "resume checkpoint already reached or exceeded requested epochs", "model_path": model_path, "train_count": len(train_rows), "val_count": len(val_rows), "epochs": args.epochs, "batch_size": 1, "lr": args.lr, "checkpoint_dir": str(resume_checkpoint) if resume_checkpoint is not None else str(checkpoint_dir), "metrics_path": str(metrics_path), "frames_per_video": args.frames_per_video, "max_train_steps": args.max_train_steps, "global_step": global_step, "completed_epochs": completed_epochs, "resume_from": str(resume_checkpoint) if resume_checkpoint is not None else "", "init_from": str(init_checkpoint) if init_checkpoint is not None else "", "init_from_stage": init_stage, } real_sft_status_path.write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8") return status def _write_running_status( *, latest_dir: Path | None, epoch: int, row_index: int, completed_epoch_count: int, status: str = "running", ) -> None: payload = { "stage": stage, "status": status, "model_path": model_path, "train_count": len(train_rows), "val_count": len(val_rows), "epochs": args.epochs, "batch_size": 1, "lr": args.lr, "checkpoint_dir": str(checkpoint_dir), "checkpoint_root_dir": str(checkpoints_root), "latest_checkpoint_dir": str(latest_dir) if latest_dir is not None else "", "metrics_path": str(metrics_path), "frames_per_video": args.frames_per_video, "max_train_steps": args.max_train_steps, "global_step": global_step, "current_epoch": epoch, "next_row_index": row_index, "completed_epochs": completed_epoch_count, "resume_from": str(resume_checkpoint) if resume_checkpoint is not None else "", "init_from": str(init_checkpoint) if init_checkpoint is not None else "", "init_from_stage": init_stage, } real_sft_status_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8") def _save_checkpoint( *, save_dir: Path, next_epoch: int, next_row_index: int, completed_epoch_count: int, reason: str, include_processor: bool, ) -> None: save_dir.mkdir(parents=True, exist_ok=True) checkpoints_root.mkdir(parents=True, exist_ok=True) (save_dir / "base_model_path.txt").write_text(str(model_path), encoding="utf-8") if include_processor: processor.save_pretrained(save_dir) if canonical_stage != "evaluator_regression": model.save_pretrained(save_dir) if pairwise_head is not None: torch.save(pairwise_head.state_dict(), save_dir / "reward_head.pt") (save_dir / "reward_head_config.json").write_text( json.dumps( { "loss": "bradley_terry_pairwise_logistic", "output": "scalar_reward", }, ensure_ascii=False, indent=2, ), encoding="utf-8", ) if evaluator_head is not None: torch.save(evaluator_head.state_dict(), save_dir / "evaluator_head.pt") (save_dir / "evaluator_head_config.json").write_text( json.dumps( { "score_names": [ "prompt_alignment", "structure_preservation", "transformation_strength", "carrier_grounding", "world_realization", "temporal_coherence", "artifact_penalty", "overall_score", ] }, ensure_ascii=False, indent=2, ), encoding="utf-8", ) if optimizer is not None: torch.save(optimizer.state_dict(), save_dir / "optimizer.pt") trainer_state = { "stage": stage, "model_path": model_path, "global_step": global_step, "completed_epochs": completed_epoch_count, "next_epoch": next_epoch, "next_row_index": next_row_index, "train_count": len(train_rows), "val_count": len(val_rows), "reason": reason, "frames_per_video": args.frames_per_video, "max_train_steps": args.max_train_steps, **_init_metadata( init_checkpoint=init_checkpoint, init_state=init_state, ), } (save_dir / "trainer_state.json").write_text( json.dumps(trainer_state, ensure_ascii=False, indent=2), encoding="utf-8", ) latest_checkpoint_path.write_text(str(save_dir), encoding="utf-8") _write_running_status( latest_dir=save_dir, epoch=min(next_epoch, args.epochs), row_index=next_row_index, completed_epoch_count=completed_epoch_count, ) print( f"[checkpoint] reason={reason} step={global_step} saved={save_dir} " f"next_epoch={next_epoch} next_row_index={next_row_index}", flush=True, ) _write_running_status( latest_dir=resume_checkpoint, epoch=start_epoch, row_index=start_row_index, completed_epoch_count=completed_epochs, ) train_limit = args.max_train_steps if args.max_train_steps > 0 else None last_next_epoch = start_epoch last_next_row_index = start_row_index terminated_early = False interval_loss_sum = 0.0 interval_steps = 0 interval_start_time = time.time() run_start_time = time.time() run_steps_completed = 0 total_planned_steps = len(train_rows) * max(args.epochs - start_epoch + 1, 0) if start_row_index > 0 and total_planned_steps > 0: total_planned_steps -= start_row_index for epoch in range(start_epoch, args.epochs + 1): epoch_loss = 0.0 epoch_steps = 0 epoch_row_start = start_row_index if epoch == start_epoch else 0 reached_train_limit = False for row_index in range(epoch_row_start, len(train_rows)): row = train_rows[row_index] device = next(model.parameters()).device optimizer.zero_grad() if canonical_stage == "pairwise_rm": candidate_scores: dict[str, torch.Tensor] = {} for candidate_key in ("a", "b"): image_paths = _extract_pairwise_candidate_frames( row, candidate_key=candidate_key, frames_per_video=args.frames_per_video, ) messages = _build_pairwise_reward_messages( stage, row, candidate_key=candidate_key, image_paths=image_paths, ) text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) image_inputs, video_inputs = process_vision_info(messages) model_inputs = processor( text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt", ) model_inputs = model_inputs.to(device) outputs = model(**model_inputs, output_hidden_states=True) hidden = outputs.hidden_states[-1] last_token_index = model_inputs["attention_mask"].sum(dim=1) - 1 pooled = hidden[torch.arange(hidden.shape[0], device=device), last_token_index] pooled = _match_head_input_dtype(pooled, pairwise_head) candidate_scores[candidate_key] = pairwise_head(pooled).view(-1) score_a = candidate_scores["a"] score_b = candidate_scores["b"] winner = str(row.get("winner", "a") or "a").strip().lower() if winner == "a": margin = score_a - score_b elif winner == "b": margin = score_b - score_a else: raise ValueError(f"Unsupported pairwise winner label: {winner}") loss = -F.logsigmoid(margin).mean() elif canonical_stage == "evaluator_regression": image_paths = _extract_training_frames(row, args.frames_per_video) messages = _build_evaluator_regression_messages(row, image_paths) text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) image_inputs, video_inputs = process_vision_info(messages) model_inputs = processor( text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt", ) model_inputs = model_inputs.to(device) with torch.inference_mode(): outputs = model(**model_inputs, output_hidden_states=True) hidden = outputs.hidden_states[-1] last_token_index = model_inputs["attention_mask"].sum(dim=1) - 1 pooled = hidden[torch.arange(hidden.shape[0], device=device), last_token_index] pooled = _match_head_input_dtype(pooled, evaluator_head) preds = evaluator_head(pooled) scores = row.get("teacher_scores", {}) or {} target = torch.tensor( [[ float(scores.get("prompt_alignment", 0.0) or 0.0), float(scores.get("structure_preservation", 0.0) or 0.0), float(scores.get("transformation_strength", 0.0) or 0.0), float(scores.get("carrier_grounding", 0.0) or 0.0), float(scores.get("world_realization", 0.0) or 0.0), float(scores.get("temporal_coherence", 0.0) or 0.0), float(scores.get("artifact_penalty", 0.0) or 0.0), float(scores.get("overall_score", 0.0) or 0.0), ]], dtype=torch.float32, device=device, ) loss = regression_criterion(preds, target) else: scores = row.get("teacher_scores", {}) or {} if canonical_stage == "evaluator_sft" and _is_aesthetic_score_schema(scores): image_paths = _extract_aesthetic_training_frames(row, args.frames_per_video) else: image_paths = _extract_training_frames( row, args.frames_per_video, include_high=canonical_stage != "evaluator_sft", ) messages, _ = _build_multimodal_messages(stage, row, image_paths) prompt_messages = messages[:-1] full_text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=False) prompt_text = processor.apply_chat_template(prompt_messages, tokenize=False, add_generation_prompt=True) image_inputs, video_inputs = process_vision_info(prompt_messages) full_inputs = processor( text=[full_text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt", ) prompt_inputs = processor( text=[prompt_text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt", ) full_inputs = full_inputs.to(device) prompt_inputs = prompt_inputs.to(device) labels = full_inputs["input_ids"].clone() prompt_len = prompt_inputs["input_ids"].shape[1] labels[:, :prompt_len] = -100 full_inputs["labels"] = labels outputs = model(**full_inputs) loss = outputs.loss loss.backward() optimizer.step() global_step += 1 run_steps_completed += 1 epoch_steps += 1 loss_value = float(loss.item()) epoch_loss += loss_value interval_loss_sum += loss_value interval_steps += 1 if summary_writer is not None: summary_writer.add_scalar("train/loss_step", loss_value, global_step) next_epoch = epoch next_row_index = row_index + 1 completed_epoch_count = epoch - 1 if next_row_index >= len(train_rows): next_epoch = epoch + 1 next_row_index = 0 completed_epoch_count = epoch last_next_epoch = next_epoch last_next_row_index = next_row_index if args.save_every_steps > 0 and global_step % args.save_every_steps == 0: _save_checkpoint( save_dir=checkpoints_root / f"step_{global_step:08d}", next_epoch=next_epoch, next_row_index=next_row_index, completed_epoch_count=completed_epoch_count, reason="step", include_processor=False, ) if args.log_every_steps > 0 and global_step % args.log_every_steps == 0: interval_elapsed = max(time.time() - interval_start_time, 1e-6) avg_interval_loss = interval_loss_sum / max(interval_steps, 1) seconds_per_step = interval_elapsed / max(interval_steps, 1) total_elapsed = max(time.time() - run_start_time, 1e-6) average_seconds_per_step = total_elapsed / max(run_steps_completed, 1) remaining_steps = max(total_planned_steps - run_steps_completed, 0) if train_limit is not None: remaining_steps = min(remaining_steps, max(train_limit - global_step, 0)) eta_seconds = remaining_steps * average_seconds_per_step eta_done_at = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time() + eta_seconds)) print( ( f"[train] epoch={epoch}/{args.epochs} step={global_step} " f"row={row_index + 1}/{len(train_rows)} " f"loss={loss_value:.6f} avg_loss={avg_interval_loss:.6f} " f"{seconds_per_step:.2f}s/step " f"eta={_format_duration(eta_seconds)} " f"done_at={eta_done_at}" ), flush=True, ) if summary_writer is not None: summary_writer.add_scalar("train/loss_interval_avg", avg_interval_loss, global_step) summary_writer.add_scalar("train/seconds_per_step", seconds_per_step, global_step) summary_writer.add_scalar("train/eta_seconds", eta_seconds, global_step) interval_loss_sum = 0.0 interval_steps = 0 interval_start_time = time.time() if train_limit is not None and global_step >= train_limit: reached_train_limit = True break avg_train_loss = epoch_loss / max(epoch_steps, 1) with metrics_path.open("a", encoding="utf-8") as f: f.write( json.dumps( {"epoch": epoch, "train_loss": avg_train_loss, "global_step": global_step}, ensure_ascii=False, ) + "\n" ) print( f"[epoch] epoch={epoch}/{args.epochs} global_step={global_step} train_loss={avg_train_loss:.6f}", flush=True, ) if summary_writer is not None: summary_writer.add_scalar("train/epoch_loss", avg_train_loss, epoch) if reached_train_limit: terminated_early = True completed_epochs = epoch if row_index + 1 >= len(train_rows) else epoch - 1 last_next_epoch = epoch if row_index + 1 < len(train_rows) else epoch + 1 last_next_row_index = 0 if row_index + 1 >= len(train_rows) else row_index + 1 _save_checkpoint( save_dir=checkpoints_root / f"step_{global_step:08d}", next_epoch=last_next_epoch, next_row_index=last_next_row_index, completed_epoch_count=completed_epochs, reason="train_limit", include_processor=False, ) break completed_epochs = epoch last_next_epoch = epoch + 1 last_next_row_index = 0 _save_checkpoint( save_dir=checkpoints_root / f"epoch_{epoch:04d}", next_epoch=last_next_epoch, next_row_index=last_next_row_index, completed_epoch_count=completed_epochs, reason="epoch", include_processor=True, ) completed_epochs = min(completed_epochs, args.epochs) _save_checkpoint( save_dir=checkpoint_dir, next_epoch=last_next_epoch if terminated_early else args.epochs + 1, next_row_index=last_next_row_index if terminated_early else 0, completed_epoch_count=completed_epochs, reason="final", include_processor=True, ) status = { "stage": stage, "status": "completed", "model_path": model_path, "train_count": len(train_rows), "val_count": len(val_rows), "epochs": args.epochs, "batch_size": 1, "lr": args.lr, "checkpoint_dir": str(checkpoint_dir), "checkpoint_root_dir": str(checkpoints_root), "latest_checkpoint_path": str(latest_checkpoint_path), "metrics_path": str(metrics_path), "frames_per_video": args.frames_per_video, "max_train_steps": args.max_train_steps, "global_step": global_step, "completed_epochs": completed_epochs, "resume_from": str(resume_checkpoint) if resume_checkpoint is not None else "", "init_from": str(init_checkpoint) if init_checkpoint is not None else "", "init_from_stage": init_stage, "save_every_steps": args.save_every_steps, } if canonical_stage == "pairwise_rm": deploy_target = PROJECT_ROOT / "models" / "critic" / "pairwise" deploy_command = f"ln -sfn '{checkpoint_dir}' '{deploy_target}'" status["deploy_recommendation"] = { "purpose": "Use the pairwise-sharpened critic as the runtime evaluator.", "target_path": str(deploy_target), "checkpoint_path": str(checkpoint_dir), "symlink_command": deploy_command, } real_sft_status_path.write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8") if real_sft_error_path.exists(): real_sft_error_path.unlink() if canonical_stage == "pairwise_rm": deploy = status["deploy_recommendation"] print( ( f"[deploy] pairwise_rm finished. Point runtime evaluator to the sharpened critic:\n" f"[deploy] {deploy['symlink_command']}" ), flush=True, ) print( f"[done] stage={stage} global_step={global_step} completed_epochs={completed_epochs} checkpoint={checkpoint_dir}", flush=True, ) return status except Exception as exc: error_payload = { "stage": stage, "status": "failed", "error_type": type(exc).__name__, "error": str(exc), "metrics_path": str(metrics_path), "checkpoint_dir": str(checkpoint_dir), "checkpoint_root_dir": str(checkpoints_root), "global_step": global_step, "completed_epochs": completed_epochs, "resume_from": str(resume_checkpoint) if resume_checkpoint is not None else "", "init_from": str(init_checkpoint) if init_checkpoint is not None else "", "init_from_stage": init_stage, } real_sft_error_path.write_text(json.dumps(error_payload, ensure_ascii=False, indent=2), encoding="utf-8") real_sft_status_path.write_text(json.dumps(error_payload, ensure_ascii=False, indent=2), encoding="utf-8") raise finally: if summary_writer is not None: summary_writer.close() def _hash_features(text: str, *, dims: int = 8) -> list[float]: digest = hashlib.sha256(text.encode("utf-8")).digest() return [digest[i] / 255.0 for i in range(dims)] def _common_features(row: dict) -> list[float]: prompt = str(row.get("prompt", "") or "") normalized_prompt = str(row.get("normalized_prompt", "") or "") compiled_prompt = str(row.get("compiled_edit_prompt", "") or "") joined = " || ".join( [ prompt, normalized_prompt, compiled_prompt, str(row.get("low_video_path", "") or ""), str(row.get("edited_video_path", "") or ""), str(row.get("high_video_path", "") or ""), ] ) return [ min(len(prompt) / 500.0, 1.0), min(len(normalized_prompt) / 500.0, 1.0), min(len(compiled_prompt) / 1000.0, 1.0), float(bool(row.get("scene_archetype"))), float(bool(row.get("style_family"))), ] + _hash_features(joined, dims=8) def _implicit_memory_features(row: dict) -> list[float]: history = row.get("history_window", []) or [] teacher = row.get("teacher_explicit_memory", {}) or {} routing = str(row.get("routing_target", "") or "") routing_flags = [ 1.0 if routing == "accept" else 0.0, 1.0 if routing == "local_refine_prompt" else 0.0, 1.0 if routing == "global_replan" else 0.0, ] return [ min(len(history) / 4.0, 1.0), min(len((teacher.get("failure_patterns", []) if isinstance(teacher, dict) else [])) / 6.0, 1.0), min(len((teacher.get("custom_skill_records", []) if isinstance(teacher, dict) else [])) / 6.0, 1.0), min(len((teacher.get("prompt_compilation_recipe_candidates", []) if isinstance(teacher, dict) else [])) / 4.0, 1.0), min(len((row.get("local_negative_teacher", {}) or {}).get("failure_tags", []) or []) / 6.0, 1.0), min(len((row.get("global_positive_teacher", {}) or {}).get("strategies", []) or []) / 4.0, 1.0), ] + routing_flags def _build_smoke_tensors(stage: str, rows: list[dict]) -> tuple[torch.Tensor, torch.Tensor]: canonical = _canonical_stage(stage) if canonical == "evaluator_sft": feature_rows = [] target_rows = [] for row in rows: features = _common_features(row) if _is_implicit_stage(stage): features += _implicit_memory_features(row) feature_rows.append(features) scores = row.get("teacher_scores", {}) or {} target_rows.append( [ float(scores.get("prompt_alignment", 0.0) or 0.0), float(scores.get("structure_preservation", 0.0) or 0.0), float(scores.get("transformation_strength", 0.0) or 0.0), float(scores.get("carrier_grounding", 0.0) or 0.0), float(scores.get("world_realization", 0.0) or 0.0), float(scores.get("temporal_coherence", 0.0) or 0.0), float(scores.get("artifact_penalty", 0.0) or 0.0), float(scores.get("overall_score", 0.0) or 0.0), ] ) return torch.tensor(feature_rows, dtype=torch.float32), torch.tensor(target_rows, dtype=torch.float32) if canonical == "reflection_sft": action_to_id = {"accept": 0, "local_refine_prompt": 1, "global_replan": 2} feature_rows = [] target_rows = [] for row in rows: scores = row.get("teacher_scores", {}) or {} features = _common_features(row) + [ float(scores.get("overall_score", 0.0) or 0.0), float(scores.get("prompt_alignment", 0.0) or 0.0), float(scores.get("world_realization", 0.0) or 0.0), float(len(row.get("failure_tags", []) or [])), ] if _is_implicit_stage(stage): features += _implicit_memory_features(row) feature_rows.append(features) target_rows.append(action_to_id[str(row.get("teacher_reflection_action", "global_replan"))]) return torch.tensor(feature_rows, dtype=torch.float32), torch.tensor(target_rows, dtype=torch.long) if canonical == "pairwise_rm": feature_rows = [] target_rows = [] for row in rows: prompt = str(row.get("prompt", "") or "") a_scores = row.get("candidate_a_scores", {}) or {} b_scores = row.get("candidate_b_scores", {}) or {} joined = " || ".join( [ prompt, str(row.get("candidate_a_video_path", "") or ""), str(row.get("candidate_b_video_path", "") or ""), ] ) feature_rows.append( [ min(len(prompt) / 500.0, 1.0), float(a_scores.get("overall_score", 0.0) or 0.0), float(b_scores.get("overall_score", 0.0) or 0.0), float(a_scores.get("world_realization", 0.0) or 0.0), float(b_scores.get("world_realization", 0.0) or 0.0), ] + _hash_features(joined, dims=8) + (_implicit_memory_features(row) if _is_implicit_stage(stage) else []) ) target_rows.append(1.0 if str(row.get("winner", "a")) == "a" else -1.0) return torch.tensor(feature_rows, dtype=torch.float32), torch.tensor(target_rows, dtype=torch.float32) return torch.zeros((0, 1), dtype=torch.float32), torch.zeros((0,), dtype=torch.float32) def _run_smoke_training( *, stage: str, train_rows: list[dict], val_rows: list[dict], output_dir: Path, epochs: int, batch_size: int, lr: float, ) -> dict: train_x, train_y = _build_smoke_tensors(stage, train_rows) val_x, val_y = _build_smoke_tensors(stage, val_rows) canonical = _canonical_stage(stage) if train_x.numel() == 0: status = { "stage": stage, "status": "skipped", "reason": "no_train_samples", "train_count": len(train_rows), "val_count": len(val_rows), } (output_dir / "smoke_status.json").write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8") return status input_dim = train_x.shape[1] if canonical == "evaluator_sft": output_dim = train_y.shape[1] model = nn.Sequential(nn.Linear(input_dim, 32), nn.ReLU(), nn.Linear(32, output_dim)) criterion = nn.MSELoss() elif canonical == "pairwise_rm": model = nn.Sequential(nn.Linear(input_dim, 32), nn.ReLU(), nn.Linear(32, 1)) criterion = None else: num_classes = 3 if canonical == "reflection_sft" else 2 model = nn.Sequential(nn.Linear(input_dim, 32), nn.ReLU(), nn.Linear(32, num_classes)) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=lr) train_loader = DataLoader(TensorDataset(train_x, train_y), batch_size=min(batch_size, len(train_rows)), shuffle=True) metrics_path = output_dir / "smoke_metrics.jsonl" metrics_path.write_text("", encoding="utf-8") for epoch in range(1, epochs + 1): model.train() train_loss_sum = 0.0 train_batches = 0 for batch_x, batch_y in train_loader: optimizer.zero_grad() pred = model(batch_x) if canonical == "pairwise_rm": reward_margin = pred.view(-1) loss = -F.logsigmoid(batch_y * reward_margin).mean() else: loss = criterion(pred, batch_y) loss.backward() optimizer.step() train_loss_sum += float(loss.item()) train_batches += 1 train_loss = train_loss_sum / max(train_batches, 1) val_loss = None if val_x.numel() > 0: model.eval() with torch.no_grad(): val_pred = model(val_x) if canonical == "pairwise_rm": val_loss = float((-F.logsigmoid(val_y * val_pred.view(-1)).mean()).item()) else: val_loss = float(criterion(val_pred, val_y).item()) with metrics_path.open("a", encoding="utf-8") as f: f.write( json.dumps( { "epoch": epoch, "train_loss": train_loss, "val_loss": val_loss, }, ensure_ascii=False, ) + "\n" ) checkpoint_path = output_dir / "smoke_checkpoint.pt" torch.save({"stage": stage, "model_state_dict": model.state_dict()}, checkpoint_path) status = { "stage": stage, "status": "completed", "train_count": len(train_rows), "val_count": len(val_rows), "epochs": epochs, "batch_size": batch_size, "lr": lr, "checkpoint_path": str(checkpoint_path), "metrics_path": str(metrics_path), } (output_dir / "smoke_status.json").write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8") return status def main() -> None: args = parse_args() dataset_path = _resolve_stage_dataset_path(args.dataset, args.stage) rows = _load_rows(dataset_path, args.max_samples) stage_rows = _materialize_stage_records(args.stage, rows) train_rows, val_rows = _split_rows(stage_rows) args.output_dir.mkdir(parents=True, exist_ok=True) datasets_dir = args.output_dir / "datasets" train_path = datasets_dir / "train.jsonl" val_path = datasets_dir / "val.jsonl" _write_jsonl(train_path, train_rows) _write_jsonl(val_path, val_rows) train_config = _stage_training_config(args, len(stage_rows)) train_config["materialized_stage_dataset"] = { "train_path": str(train_path), "val_path": str(val_path), "train_count": len(train_rows), "val_count": len(val_rows), } train_config["checkpoint_flow"] = { "resume_from": str(args.resume_from or ""), "init_from_checkpoint": str(args.init_from_checkpoint or ""), } plan = { "stage": args.stage, "base_model": args.base_model, "raw_sample_count": len(rows), "sample_count": len(stage_rows), "dataset": str(args.dataset), "resolved_dataset_path": str(dataset_path), "resume_from": str(args.resume_from or ""), "init_from_checkpoint": str(args.init_from_checkpoint or ""), "objective": _stage_objective(args.stage), "required_labels": train_config["required_labels"], "config_path": str(args.output_dir / "train_config.json"), "train_dataset_path": str(train_path), "val_dataset_path": str(val_path), "next_step": "replace this stub with actual critic fine-tuning / reward-model training entrypoint", } (args.output_dir / "train_config.json").write_text( json.dumps(train_config, ensure_ascii=False, indent=2), encoding="utf-8", ) (args.output_dir / "train_plan.json").write_text(json.dumps(plan, ensure_ascii=False, indent=2), encoding="utf-8") if args.run_smoke: smoke_status = _run_smoke_training( stage=args.stage, train_rows=train_rows, val_rows=val_rows, output_dir=args.output_dir, epochs=args.epochs, batch_size=args.batch_size, lr=args.lr, ) plan["smoke_status_path"] = str(args.output_dir / "smoke_status.json") plan["smoke_status"] = smoke_status.get("status", "") (args.output_dir / "train_plan.json").write_text(json.dumps(plan, ensure_ascii=False, indent=2), encoding="utf-8") if args.run_real_sft: real_sft_status = _run_real_sft( args=args, stage=args.stage, train_rows=train_rows, val_rows=val_rows, output_dir=args.output_dir, ) plan["real_sft_status_path"] = str(args.output_dir / "real_sft_status.json") plan["real_sft_status"] = real_sft_status.get("status", "") (args.output_dir / "train_plan.json").write_text(json.dumps(plan, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps(plan, ensure_ascii=False, indent=2)) if __name__ == "__main__": main()