Update train folder 2026-08-11

REGEN-main/train/train_demochan.py

@@ -123,6 +123,7 @@ class Settings:
     expected_replay_demos_per_task: int | None = None
     resume_expected_iteration: int | None = None
     sampling_optimizer_steps: int | None = None
+    hierarchical_chunk_sampling: str = "random"
 
 
 @dataclass(frozen=True)
@@ -355,6 +356,10 @@ def validate(settings: Settings, *, allow_busy_override: bool = False) -> tuple[
             raise ValueError("all scheduled current-task fractions must be in (0,1)")
         if settings.coverage_window_steps <= 0:
             raise ValueError("COVERAGE_WINDOW_STEPS must be positive")
+        if settings.hierarchical_chunk_sampling not in {"random", "shuffled_queue"}:
+            raise ValueError(
+                "hierarchical_chunk_sampling must be 'random' or 'shuffled_queue'"
+            )
     if (
         settings.expected_replay_demos_per_task is not None
         and settings.expected_replay_demos_per_task <= 0
@@ -493,6 +498,7 @@ def build_env(settings: Settings, paths: OutputPaths) -> dict[str, str]:
             "DEMOCHAN_MAX_REPLAY_DEMOS": str(settings.max_replay_demos),
             "DEMOCHAN_CURRENT_TASK_STEP_FRACTION": str(settings.current_task_step_fraction),
             "DEMOCHAN_HIERARCHICAL_SAMPLING": str(settings.hierarchical_sampling).lower(),
+            "DEMOCHAN_HIERARCHICAL_CHUNK_SAMPLING": settings.hierarchical_chunk_sampling,
             "DEMOCHAN_CURRENT_TASK_FRACTION_SCHEDULE": ",".join(
                 f"{step}:{fraction}"
                 for step, fraction in settings.current_task_fraction_schedule
@@ -534,7 +540,8 @@ def print_banner(
         replay_description = (
             f"{replay['demos']} demos / {replay['steps']} steps; hierarchical schedule="
             f"{list(settings.current_task_fraction_schedule)}; "
-            f"coverage_window={settings.coverage_window_steps} optimizer steps"
+            f"coverage_window={settings.coverage_window_steps} optimizer steps; "
+            f"chunk_sampling={settings.hierarchical_chunk_sampling}"
         )
     else:
         replay_description = (

REGEN-main/train/train_forget.py

@@ -63,9 +63,11 @@ if SAVE_ITER != STAGE_END_ITER:
 # 每次进程只使用当前阶段的固定比例；阶段之间通过完整checkpoint续训。
 CURRENT_TASK_FRACTION_SCHEDULE = ((0, CURRENT_TASK_FRACTION),)
 
-# 任务→轨迹→chunk三级均衡采样。每10个optimizer steps为一个覆盖窗口，
-# 窗口内保证每个任务的每条轨迹至少被选中一次。
-HIERARCHICAL_SAMPLING = True
+# 恢复demochan原始采样：先按目标current/replay比例复制当前任务的整条轨迹，
+# 再由DistributedSampler打乱所有step/chunk起点。长轨迹因包含更多step而自然
+# 获得更多训练样本；任务和轨迹不再强制等频。
+HIERARCHICAL_SAMPLING = False
+# 仅在重新启用HierarchicalReplaySampler时生效。
 COVERAGE_WINDOW_STEPS = 10
 
 # 仅Stage 1使用这个输入；Stage 2/3会强制改为同一OUTPUT_MODEL_DIR里的
@@ -122,8 +124,8 @@ def user_settings() -> shared.Settings:
         replay_data_dir=replay_dir,
         replay_task_ids=tuple(REPLAY_TASK_IDS),
         max_replay_demos=MAX_REPLAY_DEMOS_PER_TASK,
-        # HierarchicalReplaySampler使用上面的阶段表；这个标量只作兼容回退。
-        current_task_step_fraction=CURRENT_TASK_FRACTION_SCHEDULE[-1][1],
+        # demochan通过整轨迹复制把step级current/replay比例调到本阶段目标。
+        current_task_step_fraction=CURRENT_TASK_FRACTION,
         input_checkpoint=Path(INPUT_CHECKPOINT).expanduser(),
         output_model_dir=Path(OUTPUT_MODEL_DIR).expanduser(),
         max_iter=MAX_ITER,
@@ -141,7 +143,9 @@ def user_settings() -> shared.Settings:
         coverage_window_steps=COVERAGE_WINDOW_STEPS,
         expected_replay_demos_per_task=MAX_REPLAY_DEMOS_PER_TASK,
         resume_expected_iteration=(STAGE_START_ITER or None),
-        sampling_optimizer_steps=STAGE_END_ITER - STAGE_START_ITER,
+        sampling_optimizer_steps=(
+            STAGE_END_ITER - STAGE_START_ITER if HIERARCHICAL_SAMPLING else None
+        ),
     )
 
 

REGEN-main/train/train_new.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Three-stage forgetting trainer with balanced, no-replacement chunk queues.
+
+This launcher is intentionally separate from ``train_forget.py``.  It keeps the
+same current/replay -> task -> trajectory balancing, while each trajectory owns
+a shuffled queue of chunk starts.  A start is not repeated until every start in
+that trajectory has been visited once.
+
+Run a configuration check:
+    ./.venv/bin/python train/train_new.py --dry-run
+
+Start the configured stage:
+    ./.venv/bin/python train/train_new.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from dataclasses import replace
+from pathlib import Path
+
+import train_demochan as shared
+
+# =============================================================================
+# USER CONFIG
+# =============================================================================
+
+GPU_IDS = [0, 1, 2, 3, 4, 5, 6, 7]
+BATCH_SIZE_PER_GPU = 12
+GRAD_ACCUM_STEPS = 3
+
+CURRENT_DATA_DIR = (
+    "/mnt/workspace/users/luzheng/CL_lt/REGEN-main/"
+    "LIBERO-Cosmos-Policy/success_only/libero_goal_regen"
+)
+CURRENT_TASK_IDS = [6]
+
+# Stage 1/2/3 normally use replay1/replay2/replay3 respectively.
+REPLAY_DATA_DIR = "/mnt/workspace/users/luzheng/CL_lt/REGEN-main/task6/replay1"
+REPLAY_TASK_IDS = [0, 1, 2, 3, 4, 5]
+MAX_REPLAY_DEMOS_PER_TASK = 10
+
+STAGE = 1
+STAGE_CONFIGS = {
+    1: (0, 200, 200, 0.70),
+    2: (200, 500, 500, 0.60),
+    3: (500, 800, 800, 0.50),
+}
+if STAGE not in STAGE_CONFIGS:
+    raise ValueError(f"STAGE must be one of {sorted(STAGE_CONFIGS)}, got {STAGE}")
+STAGE_START_ITER, STAGE_END_ITER, SAVE_ITER, CURRENT_TASK_FRACTION = STAGE_CONFIGS[
+    STAGE
+]
+if SAVE_ITER != STAGE_END_ITER:
+    raise ValueError(
+        f"stage {STAGE} must save only at its final iteration: "
+        f"SAVE_ITER={SAVE_ITER}, STAGE_END_ITER={STAGE_END_ITER}"
+    )
+
+CURRENT_TASK_FRACTION_SCHEDULE = ((0, CURRENT_TASK_FRACTION),)
+HIERARCHICAL_SAMPLING = True
+HIERARCHICAL_CHUNK_SAMPLING = "shuffled_queue"
+COVERAGE_WINDOW_STEPS = 10
+
+INPUT_CHECKPOINT = (
+    "/mnt/workspace/users/luzheng/CL_lt/REGEN-main/checkpoints/imaginaire4-output/"
+    "cosmos_policy/cosmos_v2_finetune/"
+    "cosmos_predict2_2b_480p_libero_goal_base_stage_3gpu_40k_save4k_20260726/"
+    "checkpoints/iter_000040000"
+)
+
+# Keep this directory unchanged across all three stages.
+OUTPUT_MODEL_DIR = (
+    "/mnt/workspace/users/luzheng/CL_lt/REGEN-main/out/"
+    "cosmos_policy/cosmos_v2_finetune/forget_task6_new_sampler_20260811"
+)
+
+MAX_ITER = STAGE_END_ITER
+KEEP_NATIVE_800_STEP_LR = True
+if not KEEP_NATIVE_800_STEP_LR:
+    raise ValueError(
+        "three-stage training requires KEEP_NATIVE_800_STEP_LR=True so all launches "
+        "share one continuous 800-step LR schedule"
+    )
+MASTER_PORT = 12422
+WANDB_MODE = "offline"
+T5_TEXT_EMBEDDINGS_PATH = (
+    "/mnt/workspace/users/luzheng/CL_lt/REGEN-main/"
+    "LIBERO-Cosmos-Policy/success_only/t5_embeddings.pkl"
+)
+ALLOW_BUSY_GPUS = False
+
+# =============================================================================
+# END USER CONFIG
+# =============================================================================
+
+
+def user_settings() -> shared.Settings:
+    replay_dir = Path(REPLAY_DATA_DIR).expanduser() if REPLAY_DATA_DIR.strip() else None
+    return shared.Settings(
+        gpu_ids=tuple(GPU_IDS),
+        batch_size=BATCH_SIZE_PER_GPU,
+        grad_accum=GRAD_ACCUM_STEPS,
+        current_data_dir=Path(CURRENT_DATA_DIR).expanduser(),
+        current_task_ids=tuple(CURRENT_TASK_IDS),
+        replay_data_dir=replay_dir,
+        replay_task_ids=tuple(REPLAY_TASK_IDS),
+        max_replay_demos=MAX_REPLAY_DEMOS_PER_TASK,
+        current_task_step_fraction=CURRENT_TASK_FRACTION_SCHEDULE[-1][1],
+        input_checkpoint=Path(INPUT_CHECKPOINT).expanduser(),
+        output_model_dir=Path(OUTPUT_MODEL_DIR).expanduser(),
+        max_iter=MAX_ITER,
+        save_iter=SAVE_ITER,
+        keep_native_800_step_lr=KEEP_NATIVE_800_STEP_LR,
+        master_port=MASTER_PORT,
+        wandb_mode=WANDB_MODE,
+        t5_path=Path(T5_TEXT_EMBEDDINGS_PATH).expanduser(),
+        allow_busy_gpus=ALLOW_BUSY_GPUS,
+        process_seed=STAGE_START_ITER,
+        hierarchical_sampling=HIERARCHICAL_SAMPLING,
+        hierarchical_chunk_sampling=HIERARCHICAL_CHUNK_SAMPLING,
+        current_task_fraction_schedule=tuple(CURRENT_TASK_FRACTION_SCHEDULE),
+        coverage_window_steps=COVERAGE_WINDOW_STEPS,
+        expected_replay_demos_per_task=MAX_REPLAY_DEMOS_PER_TASK,
+        resume_expected_iteration=(STAGE_START_ITER or None),
+        sampling_optimizer_steps=STAGE_END_ITER - STAGE_START_ITER,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--allow-busy-gpus", action="store_true")
+    parser.add_argument("--output-model-dir")
+    parser.add_argument("--no-replay", action="store_true")
+    args = parser.parse_args()
+
+    settings = user_settings()
+    if args.output_model_dir:
+        settings = replace(
+            settings, output_model_dir=Path(args.output_model_dir).expanduser()
+        )
+    if args.no_replay:
+        settings = replace(
+            settings,
+            replay_data_dir=None,
+            replay_task_ids=(),
+            hierarchical_sampling=False,
+            hierarchical_chunk_sampling="random",
+            current_task_fraction_schedule=(),
+            expected_replay_demos_per_task=None,
+        )
+
+    try:
+        settings, paths, current, replay = shared.validate(
+            settings,
+            allow_busy_override=args.allow_busy_gpus,
+        )
+    except (OSError, ValueError, subprocess.SubprocessError) as error:
+        print(f"[train_new] PRECHECK FAILED: {error}", file=sys.stderr)
+        return 2
+
+    return_code = shared.run(
+        settings,
+        paths,
+        current,
+        replay,
+        dry_run=args.dry_run,
+        launcher_name="train_new",
+    )
+    if return_code != 0 or args.dry_run:
+        return return_code
+
+    try:
+        shared.validate_output_checkpoint(paths, STAGE_END_ITER)
+    except (OSError, ValueError) as error:
+        print(f"[train_new] CHECKPOINT AUDIT FAILED: {error}", file=sys.stderr)
+        return 3
+    print(
+        f"[train_new] stage {STAGE} complete: full training state saved at "
+        f"iter_{STAGE_END_ITER:09d}",
+        flush=True,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())