Add files using upload-large-folder tool

MemGen-main/common/config.py

@@ -0,0 +1,91 @@
+import json
+import logging
+
+from omegaconf import OmegaConf
+
+class Config:
+    def __init__(self, args):
+        self.config = {}
+        
+        self.args = args
+
+        user_config = self._build_opt_list(self.args.options)   
+
+        config = OmegaConf.load(self.args.cfg_path)           
+        runner_config = self.build_runner_config(config, **user_config)
+        model_config = self.build_model_config(config, **user_config)
+        dataset_config = self.build_dataset_config(config, **user_config)
+
+        # Override the default configuration with user options.
+        self.config = OmegaConf.merge(  
+            runner_config, model_config, dataset_config, user_config
+        )
+    
+
+    def _build_opt_list(self, opts):
+        opts_dot_list = self._convert_to_dot_list(opts)
+        return OmegaConf.from_dotlist(opts_dot_list)
+    
+    @staticmethod
+    def build_model_config(config, **kwargs):
+        return {"model": config.model}
+
+    @staticmethod
+    def build_runner_config(config, **kwargs):
+        return {"run": config.run}
+
+    @staticmethod
+    def build_dataset_config(config, **kwargs):
+        dataset = config.get("dataset", None)
+        if dataset is None:
+            raise KeyError(
+                "Expecting 'dataset' as the root key for dataset configuration."
+            )
+        
+        return dict(dataset=dataset)
+    
+    def _convert_to_dot_list(self, opts):
+        if opts is None:
+            opts = []
+
+        if len(opts) == 0:
+            return opts
+
+        has_equal = opts[0].find("=") != -1
+
+        if has_equal:
+            return opts
+
+        return [(opt + "=" + value) for opt, value in zip(opts[0::2], opts[1::2])]
+    
+    def get_config(self):
+        return self.config
+
+    @property
+    def run_cfg(self):
+        return self.config.run
+
+    @property
+    def dataset_cfg(self):
+        return self.config.dataset
+
+    @property
+    def model_cfg(self):
+        return self.config.model
+
+    def pretty_print(self):
+        logging.info("\n=====  Running Parameters    =====")
+        logging.info(self._convert_node_to_json(self.config.run))
+
+        logging.info("\n======  Dataset Attributes  ======")
+        logging.info(self._convert_node_to_json(self.config.dataset))
+
+        logging.info(f"\n======  Model Attributes  ======")
+        logging.info(self._convert_node_to_json(self.config.model))
+    
+    def _convert_node_to_json(self, node):
+        container = OmegaConf.to_container(node, resolve=True)  
+        return json.dumps(container, indent=4, sort_keys=True)  
+
+    def to_dict(self):
+        return OmegaConf.to_container(self.config)

MemGen-main/common/logger.py

@@ -0,0 +1,10 @@
+import os
+import logging
+
+def setup_logger(output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        handlers=[logging.StreamHandler(), logging.FileHandler(os.path.join(output_dir, 'log.txt'))],
+    )

MemGen-main/configs/latent_memory/gpqa.yaml

@@ -0,0 +1,173 @@
+model: 
+  # base llm
+  model_name: Qwen/Qwen2.5-1.5B-Instruct
+  load_model_path: null
+  
+  # max prompt/inference augmentation num
+  max_prompt_aug_num: 1  # single turn
+  max_inference_aug_num: 5
+
+  # weaver configs
+  weaver:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    prompt_latents_len: 8
+    inference_latents_len: 8
+    
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+  # trigger configs
+  trigger:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    active: False
+   
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+# dataset configs
+dataset: 
+  name: gpqa
+  mode: sft  # NOTE - options: ["sft", "grpo"], should manually keep align with the training method in `run` configs
+  sft:
+    valid_ratio: 0.1
+  grpo: 
+    valid_ratio: 0.1
+
+# training/evaluation configs
+run: 
+
+  seed: 42
+  
+  # route
+  mode: train
+  train_weaver: True
+  train_weaver_method: sft    # sft or grpo
+  train_trigger: False
+  train_trigger_method: grpo  # grpo only
+
+  # processor training configs
+  weaver:
+    
+    # sft configs
+    sft:
+      # epochs and batchsize
+      num_train_epochs: 2
+      per_device_train_batch_size: 4
+      per_device_eval_batch_size: 4
+      gradient_accumulation_steps: 1
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+ 
+      assistant_only_loss: False   # used only in conversational dataset
+      max_length: 1024  # max sequence length
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+      
+    # grpo configs
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8   
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: grpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+
+  # trigger training configs
+  trigger:
+
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+
+      # optimizer configs
+      optim: adamw_torch
+      learning_rate: 1e-5
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+  
+  # interaction config for evaluation
+  interaction:
+    max_turns: 1
+    max_start_length: 1024     # Maximum length of the initial prompt.
+    max_prompt_length: 4096    # Maximum prompt length during multi-turn interactions (includes all conversation history across turns).
+    max_response_length: 1024
+    max_obs_length: 512
+    temperature: 1.0
+    batch_size: 8
+    weaver_do_sample: False
+    trigger_do_sample: False

MemGen-main/configs/latent_memory/gsm8k.yaml

@@ -0,0 +1,173 @@
+model: 
+  # base llm
+  model_name: Qwen/Qwen2.5-1.5B-Instruct
+  load_model_path: null
+  
+  # max prompt/inference augmentation num
+  max_prompt_aug_num: 1  # single turn
+  max_inference_aug_num: 5
+
+  # weaver configs
+  weaver:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    prompt_latents_len: 8
+    inference_latents_len: 8
+    
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+  # trigger configs
+  trigger:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    active: False
+   
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+      
+# dataset configs
+dataset: 
+  name: gsm8k
+  mode: sft  # options: ["sft", "grpo"], should manually keep align with the training method in `run` configs
+  sft:
+    val_ratio: 0.1
+  grpo: 
+    val_ratio: 0.1
+
+# training/evaluation configs
+run: 
+
+  seed: 42
+  
+  # route
+  mode: train
+  train_weaver: True
+  train_weaver_method: sft    # sft or grpo
+  train_trigger: False
+  train_trigger_method: grpo  # grpo only
+
+  # processor training configs
+  weaver:
+    
+    # sft configs
+    sft:
+      # epochs and batchsize
+      num_train_epochs: 2
+      per_device_train_batch_size: 4
+      per_device_eval_batch_size: 4
+      gradient_accumulation_steps: 1
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+ 
+      assistant_only_loss: True
+      max_length: 1024  # max sequence length
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+      
+    # grpo configs
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8   
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 1024
+      temperature: 1.0
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+
+  # trigger training configs
+  trigger:
+
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 1024
+      temperature: 1.0
+
+      # optimizer configs
+      optim: adamw_torch
+      learning_rate: 1e-6
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+  
+  # interaction config for evaluation
+  interaction:
+    max_turns: 1
+    max_start_length: 1024     # Maximum length of the initial prompt.
+    max_prompt_length: 4096    # Maximum prompt length during multi-turn interactions (includes all conversation history across turns).
+    max_response_length: 1024
+    max_obs_length: 512
+    temperature: 0.0
+    batch_size: 8
+    weaver_do_sample: False
+    trigger_do_sample: False

MemGen-main/configs/latent_memory/kodcode.yaml

@@ -0,0 +1,176 @@
+model: 
+  # base llm
+  model_name: Qwen/Qwen2.5-1.5B-Instruct
+  load_model_path: null
+  
+  # max prompt/inference augmentation num
+  max_prompt_aug_num: 1  # single turn
+  max_inference_aug_num: 5
+
+  # weaver configs
+  weaver:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    prompt_latents_len: 8
+    inference_latents_len: 8
+    
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+  # trigger configs
+  trigger:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    active: False
+   
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+dataset: 
+  name: kodcode
+  mode: sft
+  sft:
+    train_ratio: 0.7
+    valid_ratio: 0.1
+    test_ratio: 0.2
+  grpo: 
+    train_ratio: 0.7
+    valid_ratio: 0.1
+    test_ratio: 0.2
+
+# training/evaluation configs
+run: 
+
+  seed: 42
+  
+  # route
+  mode: train
+  train_weaver: True
+  train_weaver_method: sft    # sft or grpo
+  train_trigger: False
+  train_trigger_method: grpo  # grpo only
+
+  # processor training configs
+  weaver:
+    
+    # sft configs
+    sft:
+      # epochs and batchsize
+      num_train_epochs: 2
+      per_device_train_batch_size: 4
+      per_device_eval_batch_size: 4
+      gradient_accumulation_steps: 1
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+ 
+      assistant_only_loss: False   # used only in conversational dataset
+      max_length: 1024  # max sequence length
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+      
+    # grpo configs
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8   
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+
+  # trigger training configs
+  trigger:
+
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+
+      # optimizer configs
+      optim: adamw_torch
+      learning_rate: 1e-5
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+  
+  # interaction config for evaluation
+  interaction:
+    max_turns: 1
+    max_start_length: 1024     # Maximum length of the initial prompt.
+    max_prompt_length: 4096    # Maximum prompt length during multi-turn interactions (includes all conversation history across turns).
+    max_response_length: 1024
+    max_obs_length: 512
+    temperature: 0.0
+    batch_size: 8
+    weaver_do_sample: False
+    trigger_do_sample: False

MemGen-main/configs/latent_memory/triviaqa.yaml

@@ -0,0 +1,172 @@
+model: 
+  # base llm
+  model_name: Qwen/Qwen2.5-1.5B-Instruct
+  load_model_path: null
+  
+  # max prompt/inference augmentation num
+  max_prompt_aug_num: 8  # single turn
+  max_inference_aug_num: 0
+
+  # weaver configs
+  weaver:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    prompt_latents_len: 8
+    inference_latents_len: 8
+    
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+
+  # trigger configs
+  trigger:
+    model_name: Qwen/Qwen2.5-1.5B-Instruct
+    active: False
+   
+    lora_config:
+      r: 16
+      lora_alpha: 32
+      target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+      lora_dropout: 0.1
+      bias: "none"
+      task_type: "CAUSAL_LM"
+  
+dataset: 
+    name: triviaqa
+    mode: sft
+    sft:
+      valid_ratio: 0.1
+    grpo:
+      valid_ratio: 0.1
+        
+
+# training/evaluation configs
+run: 
+
+  seed: 42
+  
+  # route
+  mode: train
+  train_weaver: True
+  train_weaver_method: sft    # sft or grpo
+  train_trigger: False
+  train_trigger_method: grpo  # grpo only
+
+  # processor training configs
+  weaver:
+    
+    # sft configs
+    sft:
+      # epochs and batchsize
+      num_train_epochs: 2
+      per_device_train_batch_size: 4
+      per_device_eval_batch_size: 4
+      gradient_accumulation_steps: 1
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+ 
+      assistant_only_loss: True   # used only in conversational dataset
+      max_length: 1024  # max sequence length
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+      
+    # grpo configs
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8   
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: grpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+      
+      # optimizer configs
+      optim: adamw_torch
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      learning_rate: 1e-5
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+
+  # trigger training configs
+  trigger:
+
+    grpo:
+      num_train_epochs: 1
+      per_device_train_batch_size: 8
+      per_device_eval_batch_size: 8
+      num_generations: 8
+      num_iterations: 1
+      gradient_accumulation_steps: 1
+      beta: 0.0
+      loss_type: bnpo
+
+      max_prompt_length: 1024
+      max_completion_length: 512
+      temperature: 1.0
+
+      # optimizer configs
+      optim: adamw_torch
+      learning_rate: 1e-5
+      lr_scheduler_type: cosine
+      warmup_ratio: 0.1
+      
+      # duration
+      logging_strategy: steps
+      logging_steps: 1
+      eval_strategy: epoch
+      eval_steps: 100
+      save_strategy: epoch
+      save_steps: 100
+
+      remove_unused_columns: False
+      load_best_model_at_end: True
+      bf16: True
+      report_to:  
+        - tensorboard
+  
+  interaction:
+    max_turns: 5
+    max_start_length: 1024     # Maximum length of the initial prompt.
+    max_prompt_length: 4096    # Maximum prompt length during multi-turn interactions (includes all conversation history across turns).
+    max_response_length: 1024
+    max_obs_length: 512
+    temperature: 0.0
+    batch_size: 8
+    weaver_do_sample: False
+    trigger_do_sample: False

MemGen-main/configs/zero2.yaml

@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: false
+  zero_stage: 2
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 1  # 会被脚本自动覆盖，无需手动修改
+main_process_port: 44326
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

MemGen-main/data/__init__.py

@@ -0,0 +1,26 @@
+from data.base_builder import BaseBuilder
+from data.base_env import (
+    BaseEnv,
+    StaticEnv,
+    DynamicEnv,
+)
+from data.gpqa.builder import GPQABuilder
+from data.gsm8k.builder import GSM8KBuilder
+from data.kodcode.builder import KodCodeBuilder
+from data.triviaqa.builder import TriviaQABuilder
+
+_DATA_BUILDER_MAP = {
+    "gpqa": GPQABuilder,
+    "gsm8k": GSM8KBuilder,
+    "kodcode": KodCodeBuilder,
+    "triviaqa": TriviaQABuilder
+}
+
+def get_data_builder(dataset_cfg) -> BaseBuilder:
+    if dataset_cfg.get("name") not in _DATA_BUILDER_MAP:
+        raise ValueError("Unsupported dataset.")
+    
+    builder_cls = _DATA_BUILDER_MAP[dataset_cfg.get("name")]
+    builder = builder_cls(dataset_cfg)
+
+    return builder

MemGen-main/data/base_builder.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Type
+
+from datasets import DatasetDict
+
+from data.base_env import BaseEnv
+
+class BaseBuilder(ABC):
+
+    def __init__(self, cfg: dict = None):
+        super().__init__()
+        
+        self.mode = cfg.get("mode", "sft")
+        self.config = cfg.get(self.mode)
+    
+    def get_dataset_dict(self) -> DatasetDict:
+        method_builder_map = {
+            "sft": self._build_sft_datasets,
+            "grpo": self._build_rl_datasets,
+        }
+
+        if self.mode not in method_builder_map:
+            raise ValueError("Unsupported datasets mode")
+        
+        return method_builder_map[self.mode]()
+    
+    @abstractmethod
+    def get_env_cls(self) -> Type[BaseEnv]:
+        ...
+
+    @abstractmethod
+    def _build_sft_datasets(self) -> DatasetDict:
+        ...
+    
+    @abstractmethod
+    def _build_rl_datasets(self) -> DatasetDict:
+        ...
+    

MemGen-main/data/base_env.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Literal, Dict, Tuple
+
+class BaseEnv(ABC):
+    ENV_CARD: Literal["STATIC", "DYNAMIC"] = None
+
+    def __init__(self, config):
+        self.config = config
+
+    @classmethod
+    @abstractmethod
+    def compute_reward(cls, **kwargs):
+        ...
+
+
+class StaticEnv(BaseEnv):
+    ENV_CARD = "STATIC"
+    
+
+class DynamicEnv(BaseEnv):
+    ENV_CARD = "DYNAMIC"
+    
+    @abstractmethod
+    def set_env(self, task_config: Dict) -> Tuple[str, str]:  
+        ...
+
+    @classmethod
+    @abstractmethod
+    def preprocess_action(self, action: str) -> str:
+        ...
+    
+    @abstractmethod
+    def step(self, action: str) -> Tuple[str, bool]:
+        ...
+    
+    @abstractmethod
+    def feedback(self) -> Tuple[float, bool]:
+        ...

MemGen-main/data/gpqa/builder.py

@@ -0,0 +1,102 @@
+import random
+from datasets import DatasetDict, load_dataset
+ 
+from data.base_builder import BaseBuilder
+from data.gpqa.env import GPQAEnv
+
+class GPQABuilder(BaseBuilder):
+
+    def get_env_cls(self):
+        return GPQAEnv
+    
+    def _build_datasets(self) -> DatasetDict:
+        # download data
+        raw_train_dataset = load_dataset("Idavidrein/gpqa", "gpqa_main")["train"]
+        raw_test_dataset = load_dataset("Idavidrein/gpqa", "gpqa_diamond")["train"]
+        val_size = int(len(raw_train_dataset) * self.config.get("valid_ratio"))
+        split = raw_train_dataset.train_test_split(test_size=val_size, shuffle=True)
+        raw_train_dataset, raw_valid_dataset = split["train"], split["test"]
+        
+        # preprocess
+        train_dataset = raw_train_dataset.map(self._preprocess).select_columns(self._keep_keys())
+        valid_dataset = raw_valid_dataset.map(self._preprocess).select_columns(self._keep_keys())
+        test_dataset = raw_test_dataset.map(self._preprocess).select_columns(self._keep_keys())
+
+        # build dataset
+        dataset_dict = DatasetDict()
+        dataset_dict["train"] = train_dataset
+        dataset_dict["valid"] = valid_dataset
+        dataset_dict["test"] = test_dataset
+
+        return dataset_dict
+
+    def _build_sft_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+
+
+    def _build_rl_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+    
+    @classmethod
+    def _preprocess(cls, example: dict):
+        
+        def build_answer_map(candidates: list[str]) -> dict[str, dict[str, object]]:
+
+            indices = list(range(len(candidates)))
+            random.shuffle(indices)
+
+            orders = [chr(ord("A") + i) for i in range(len(candidates))]
+
+            answer_map = {}
+            for idx, candidate_idx in enumerate(indices):
+                answer = candidates[candidate_idx]
+                answer_map[answer] = {
+                    "order": orders[idx],
+                    "is_correct": (candidate_idx == 0) 
+                }
+
+            return answer_map
+        
+        def build_question(question, answer_map: dict) -> str:
+            result = question.strip() + "\n\nPlease choose one of the following options:\n"
+
+            sorted_items = sorted(answer_map.items(), key=lambda x: x[1]["order"])
+
+            for answer, meta in sorted_items:
+                result += f"{meta['order']}. {answer}\n"
+
+            return result
+
+        def build_answer(rationale: str, answer_map: dict) -> str:
+            correct_answer = None
+            for key, value in answer_map.items():
+                if value.get("is_correct") is True:
+                    correct_answer = value.get("order")
+            assert correct_answer is not None
+            return rationale + f"\n\nTherefore, the final answer is \\boxed{{{correct_answer}}}"
+
+        question = example["Question"].strip()
+        explanation = example["Explanation"].strip()
+        correct_answer = example["Correct Answer"].strip()
+        incorrect_answer1 = example["Incorrect Answer 1"].strip() 
+        incorrect_answer2 = example["Incorrect Answer 2"].strip()
+        incorrect_answer3 = example["Incorrect Answer 3"].strip()
+        
+        answers_map = build_answer_map([correct_answer, incorrect_answer1, incorrect_answer2, incorrect_answer3])
+        question = build_question(question, answers_map)
+        answer = build_answer(explanation, answers_map)
+
+        format_template = r"""Solve the problem with proper reasoning, and make sure to put the FINAL CHOICE inside \boxed{}."""
+        prompt_template = "Question: {prompt}\n"   
+        processed_prompt = format_template + prompt_template.format(prompt=question)
+
+        text_output = {
+            "prompt": processed_prompt,
+            "completion": answer,
+            "solution": answer    
+        }
+        return text_output
+    
+    @classmethod
+    def _keep_keys(cls):
+        return ["prompt", "completion", "solution"]

MemGen-main/data/gpqa/env.py

@@ -0,0 +1,14 @@
+from data.utils.math_utils import compute_score
+from data.base_env import StaticEnv
+
+class GPQAEnv(StaticEnv):
+
+    def __init__(self, config):
+        super().__init__(config)
+
+    @classmethod
+    def compute_reward(cls, completions: list[str], solution: list[str], **kwargs) -> list[float]:
+        
+        scores = [compute_score(completion=c, ground_truth=s) for c, s in zip(completions, solution)]
+        return scores
+

MemGen-main/data/gsm8k/builder.py

@@ -0,0 +1,74 @@
+from datasets import DatasetDict, load_dataset
+from typing import Dict
+ 
+from data.base_builder import BaseBuilder
+from data.gsm8k.env import GSM8KEnv
+
+class GSM8KBuilder(BaseBuilder):   # Env
+    
+    def get_env_cls(self):
+        return GSM8KEnv
+
+    def _build_datasets(self) -> DatasetDict:
+
+        # download data
+        raw_dataset = load_dataset("gsm8k", "main")
+        raw_train_dataset, raw_test_dataset = raw_dataset['train'], raw_dataset['test']
+        val_size = int(len(raw_train_dataset) * self.config.get("val_ratio"))
+        split = raw_train_dataset.train_test_split(test_size=val_size, shuffle=True)
+        raw_train_dataset, raw_valid_dataset = split["train"], split["test"]
+        
+        # preprocess
+        num_workers = 32
+        train_dataset = raw_train_dataset.map(self._preprocess, num_proc=num_workers).select_columns(self._keep_keys())
+        valid_dataset = raw_valid_dataset.map(self._preprocess, num_proc=num_workers).select_columns(self._keep_keys())
+        test_dataset = raw_test_dataset.map(self._preprocess, num_proc=num_workers).select_columns(self._keep_keys())
+        
+        # build dataset
+        dataset_dict = DatasetDict()
+        dataset_dict["train"] = train_dataset
+        dataset_dict["valid"] = valid_dataset
+        dataset_dict["test"] = test_dataset
+
+        return dataset_dict
+    
+    def _build_sft_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+
+
+    def _build_rl_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+    
+    @classmethod
+    def _preprocess(cls, example: Dict):
+        def _preprocess_answer(answer: str) -> str:
+            raw_answer_list = answer.split("\n####")
+            rationale = raw_answer_list[0]
+            clean_answer = raw_answer_list[-1].strip()
+            boxed_answer = "\\boxed{" + clean_answer + "}"
+            new_string = rationale + boxed_answer
+            return new_string.strip()
+        
+        format_template = r"""Solve the math problem with proper reasoning, and make sure to put the FINAL ANSWER inside \boxed{}."""
+        prompt_template = "Question: {prompt}\n"
+         
+        question = example["question"].strip()
+        answer = example["answer"].strip()
+
+        processed_prompt = format_template + prompt_template.format(prompt=question)
+        processed_label = _preprocess_answer(answer)
+
+        text_output = {
+            "prompt": [{"role": "user", "content": processed_prompt}],
+            "completion": [{"role": "assistant", "content": processed_label}],
+            "solution": processed_label,     
+            "test": processed_label,
+        }
+        
+        # NOTE - To use the built-in tokenization mechanism of SFTTrainer, 
+        # it is necessary to ensure that the prompt + completion is lossless.
+        return text_output
+    
+    @classmethod
+    def _keep_keys(cls):
+        return ["prompt", "completion", "solution"]

MemGen-main/data/gsm8k/env.py

@@ -0,0 +1,13 @@
+from data.utils.math_utils import compute_score
+from data.base_env import StaticEnv
+
+class GSM8KEnv(StaticEnv):
+
+    def __init__(self, config):
+        super().__init__(config)
+
+    @classmethod
+    def compute_reward(cls, completions: list[str], solution: list[str], **kwargs) -> list[float]:
+        
+        scores = [compute_score(completion=c, ground_truth=s) for c, s in zip(completions, solution)]
+        return scores  

MemGen-main/data/kodcode/builder.py

@@ -0,0 +1,76 @@
+from datasets import DatasetDict, load_dataset
+from typing import Dict
+ 
+from data.base_builder import BaseBuilder
+from data.kodcode.env import KodCodeEnv
+
+class KodCodeBuilder(BaseBuilder):  
+    
+    def get_env_cls(self):
+        return KodCodeEnv
+    
+    def _build_datasets(self) -> DatasetDict:
+        # download dataset
+        all_dataset = load_dataset("KodCode/KodCode-Light-RL-10K") 
+        all_correct_dataset = all_dataset["train"]                 
+        
+        # train, valid, test dataset split
+        train_ratio, valid_ratio, test_ratio = self.config.get("train_ratio"), self.config.get("valid_ratio"), self.config.get("test_ratio")
+        assert train_ratio + valid_ratio + test_ratio == 1
+        
+        all_size = len(all_correct_dataset)
+        test_size = int(all_size * test_ratio)
+        split = all_correct_dataset.train_test_split(test_size=test_size, shuffle=True)
+        train_valid_dataset, test_dataset = split["train"], split["test"]
+        
+        valid_size = int(len(train_valid_dataset) * valid_ratio / (train_ratio + valid_ratio))
+        split = train_valid_dataset.train_test_split(test_size=valid_size, shuffle=True)
+        train_dataset, valid_dataset = split["train"], split["test"]
+        
+        # preprocess
+        train_dataset = train_dataset.map(self._sft_preprocess).select_columns(self._sft_keep_keys())
+        valid_dataset = valid_dataset.map(self._sft_preprocess).select_columns(self._sft_keep_keys())
+        test_dataset = test_dataset.map(self._sft_preprocess).select_columns(self._sft_keep_keys())
+        
+        # build dataset dict
+        dataset_dict = DatasetDict()
+        dataset_dict["train"] = train_dataset
+        dataset_dict["valid"] = valid_dataset
+        dataset_dict["test"] = test_dataset
+
+        return dataset_dict
+
+    def _build_sft_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+
+
+    def _build_rl_datasets(self) -> DatasetDict:
+        return self._build_datasets()
+
+    @classmethod
+    def _sft_preprocess(cls, example: Dict):
+        
+        format_template = r"Write an efficient and correct Python function to solve the following problem."
+        prompt_template = "Question: {prompt}\n"
+
+        question = example["question"].strip()
+        solution = example["solution"].strip()
+
+        processed_prompt = format_template + prompt_template.format(prompt=question)
+        processed_label = solution
+
+        text_output = {
+            "prompt": [{"role": "user", "content": processed_prompt}],
+            "completion": [{"role": "assistant", "content": processed_label}],
+            "solution": processed_label,
+            "test": example["test"].strip(),  
+            "test_info": example["test_info"]
+        }
+
+        return text_output
+    
+    @classmethod
+    def _sft_keep_keys(cls):
+        return ["prompt", "completion", "solution", "test", "test_info"]
+
+

MemGen-main/data/kodcode/env.py

@@ -0,0 +1,36 @@
+import re
+
+from data.base_env import StaticEnv
+from data.utils.code_utils import PyExecutor, extract_python_code
+
+class KodCodeEnv(StaticEnv):
+
+    def __init__(self, config):
+        super().__init__(config)
+
+    @classmethod
+    def _rename_func(cls, answer: str, function_name: str) -> str:
+        """
+        Replace the name of the first function in `answer` with `function_name`.
+        Only modifies the function name, keeps everything else intact.
+        """
+        pattern = r"def\s+(\w+)\s*\("
+
+        new_answer = re.sub(pattern, f"def {function_name}(", answer, count=1)
+        return new_answer
+
+    @classmethod
+    def compute_reward(cls, completions: list[str], test: list[str], test_info: list, **kwargs) -> list[float]:
+ 
+        py_executor = PyExecutor()
+        scores = []
+        for completion, t, tf in zip(completions, test, test_info): 
+            func_blocks = extract_python_code(completion.strip())
+            collected_answer = '\n'.join(func_blocks)
+            renamed_answer = cls._rename_func(collected_answer, tf[0]["function_name"])
+            _, _, results = py_executor.execute(renamed_answer, [t])
+
+            score = sum(results) / len(results)  
+            scores.append(score)
+        
+        return scores

MemGen-main/data/triviaqa/builder.py

@@ -0,0 +1,139 @@
+from datasets import DatasetDict, load_dataset
+from typing import Dict, List
+import re
+import copy
+
+from data.base_builder import BaseBuilder
+from data.triviaqa.env import TriviaQAEnv
+
+
+TRIVIAQA_SYSTEM_PROMPT = """Answer the given question. \
+You must conduct reasoning inside <think> and </think> first every time you get new information. \
+After reasoning, if you find you lack some knowledge, you can call a search engine by <search> query </search> and it will return the top searched results between <information> and </information>. \
+You can search as many times as your want. \
+If you find no further external knowledge needed, you can directly provide the answer inside <answer> and </answer>, without detailed illustrations. For example, <answer> Beijing </answer>. \
+"""
+
+class TriviaQABuilder(BaseBuilder):  # Env
+
+    def get_env_cls(self):
+        return TriviaQAEnv
+
+    def _build_sft_datasets(self) -> DatasetDict:
+        
+        # build train/valid dataset from agentbank
+        train_ds = load_dataset("Solaris99/AgentBank", "triviaqa")["train"]
+        
+        valid_ratio = self.config.get("valid_ratio")
+        all_size = len(train_ds)
+        valid_size = int(all_size * valid_ratio)
+        split = train_ds.train_test_split(test_size=valid_size, shuffle=True)
+        raw_train_dataset, raw_valid_dataset = split["train"], split["test"]
+
+        # build test dataset from triviaqa
+        ds = load_dataset("mandarjoshi/trivia_qa", "rc.wikipedia.nocontext")   
+        raw_test_dataset = ds["validation"]  
+
+        # preprocess
+        num_workers = 32
+        train_dataset = raw_train_dataset.map(self._sft_preprocess, num_proc=num_workers).select_columns(self._sft_keep_keys())
+        valid_dataset = raw_valid_dataset.map(self._sft_preprocess, num_proc=num_workers).select_columns(self._sft_keep_keys())
+        test_dataset = raw_test_dataset.map(self._rl_preprocess, num_proc=num_workers).select_columns(self._rl_keep_keys())
+        
+        dataset_dict = DatasetDict()
+        dataset_dict["train"] = train_dataset
+        dataset_dict["valid"] = valid_dataset
+        dataset_dict["test"] = test_dataset
+
+        return dataset_dict
+
+    def _build_rl_datasets(self) -> DatasetDict:
+        
+        ds = load_dataset("mandarjoshi/trivia_qa", "rc.wikipedia.nocontext")   
+        raw_train_dataset = ds["train"]
+        raw_valid_dataset = ds["validation"]
+        raw_test_dataset = ds["test"]
+       
+        num_workers = 32
+        train_dataset = raw_train_dataset.map(self._rl_preprocess, num_proc=num_workers).select_columns(self._rl_keep_keys())
+        valid_dataset = raw_valid_dataset.map(self._rl_preprocess, num_proc=num_workers).select_columns(self._rl_keep_keys())
+        test_dataset = raw_test_dataset.map(self._rl_preprocess, num_proc=num_workers).select_columns(self._rl_keep_keys())
+
+        dataset_dict = DatasetDict()
+        dataset_dict["train"] = train_dataset
+        dataset_dict["valid"] = valid_dataset
+        dataset_dict["test"] = test_dataset
+
+        return dataset_dict
+
+    @classmethod
+    def _sft_preprocess(cls, example: Dict):
+
+        def _add_user_special_tokens(content: str) -> str:
+            observation_match = re.search(r'Observation: (.*)', content)
+
+            if observation_match:
+                observation_content = f"<observation> {observation_match.group(1).strip()} </observation>"
+            else:
+                observation_content = content
+            
+            return observation_content
+
+        def _add_assistant_special_tokens(content: str) -> str:
+            thought_match = re.search(r'Thought: (.*?)(?=\nAction:|\nFinal Answer:|$)', content, re.DOTALL)
+            action_match = re.search(r'Action: search\[(.*?)\]', content)
+            answer_match = re.search(r'Final Answer: (.*)', content)
+
+            parts = []
+            
+            if thought_match:
+                thought_content = thought_match.group(1).strip()
+                parts.append(f"<think> {thought_content} </think>")
+            
+            if action_match:
+                action_content = action_match.group(1).strip()
+                parts.append(f"<search> {action_content} </search>")
+
+            if answer_match:
+                answer_content = answer_match.group(1).strip()
+                parts.append(f"<answer> {answer_content} </answer>")
+            
+            aggregated_content = "\n".join(parts)
+            return aggregated_content
+
+        messages = []
+        system_prompt = {"role": "system", "content": TRIVIAQA_SYSTEM_PROMPT.strip()}
+        messages.append(system_prompt)
+
+        for sample in example["conversations"]:
+            message = {}
+            # role
+            if sample["from"] == "human":
+                message["role"] = "user"
+                message["content"] = _add_user_special_tokens(sample["value"])
+            elif sample["from"] == "gpt":
+                message["role"] = "assistant"
+                message["content"] = _add_assistant_special_tokens(sample["value"])
+            else:
+                raise ValueError("Unsupported Role type.")
+            
+            messages.append(message)
+        
+        return {
+            "messages": messages
+        }
+
+    @classmethod
+    def _sft_keep_keys(cls) -> List[str]:
+        return ["messages"]
+
+    @classmethod
+    def _rl_preprocess(cls, example: Dict) -> Dict:
+        output = copy.deepcopy(example)
+        output["answer"] = output["answer"]["normalized_aliases"]
+        output["prompt"] = output["question"]
+        return output
+
+    @classmethod
+    def _rl_keep_keys(cls) -> List[str]:
+        return ["prompt", "answer"]

MemGen-main/data/triviaqa/env.py

@@ -0,0 +1,120 @@
+from typing import List, Dict, Tuple
+import re
+
+from data.base_env import DynamicEnv
+from data.utils.retrieval_utils import Retriever
+
+class TriviaQAEnv(DynamicEnv):
+   
+    def __init__(self, configs: Dict):
+        super().__init__(configs)
+        self.explorer = Retriever()
+
+    def set_env(self, task_config: Dict) -> None:
+        if task_config.get('answer') is None:
+            raise ValueError('Please provide the answer for the task')
+        if task_config.get("prompt") is None:
+            raise ValueError('Please provide the prompt for the task')
+
+        self.task_config = task_config
+        
+        self._reset()
+
+        from data.triviaqa.builder import TRIVIAQA_SYSTEM_PROMPT
+        return TRIVIAQA_SYSTEM_PROMPT, task_config["prompt"]
+    
+    def _reset(self):
+        self.done = False
+        self.reward = 0.0
+
+    def step(self, action: str) -> Tuple[str, float, bool]:
+        action = self.preprocess_action(action)
+        action_type, action_content = self._process_action(action)
+        observation = None
+        
+        if action_type == "search":
+            try:
+                observation = self.explorer.batch_search([action_content])[0]
+            except Exception as e:
+                observation = f'Cannot find corresponding pages.'     
+            self.done = False
+            self.reward = 0.0
+
+        elif action_type == "answer":
+            observation = ""
+            self.done = True
+            self.reward = 1.0 if self._check_answer(action_content, self.task_config["answer"]) else 0.0
+        else:
+            observation = "\nMy previous action is invalid. \
+If I want to search, I should put the query between <search> and </search>. \
+If I want to give the final answer, I should put the answer between <answer> and </answer>. Let me try again.\n"
+            self.done = False
+            self.reward = 0.0
+
+        return observation, self.reward, self.done
+    
+    @classmethod
+    def preprocess_action(cls, action: str) -> str:
+        if "</search>" in action:
+            return action.split("</search>", 1)[0] + "</search>"
+        elif "</answer>" in action:
+            return action.split("</answer>", 1)[0] + "</answer>"
+        else:
+            return action
+    
+    @classmethod
+    def _process_action(cls, action: str):
+        action = action.strip()
+
+        if "<search>" in action and "</search>" in action:
+            start = action.index("<search>") + len("<search>")
+            end = action.index("</search>")
+            content = action[start:end].strip().split("\n", 1)[0].strip()
+            return "search", content
+
+        if "<answer>" in action and "</answer>" in action:
+            start = action.index("<answer>") + len("<answer>")
+            end = action.index("</answer>")
+            content = action[start:end].strip().split("\n", 1)[0].strip()
+            return "answer", content
+
+        return "think", action
+    
+    def _check_answer(self, answer: str, ground_truth: List[str]):
+        answer = answer.lower()
+        for gt in ground_truth:
+            if gt.lower() in answer:
+                return True
+        
+        return False
+    
+    def feedback(self) -> float:
+        return self.reward
+
+    @classmethod
+    def compute_reward(cls, completions: List[str], envs: List['TriviaQAEnv'], **kwargs) -> List[float]:
+        scores = []
+        for completion, env in zip(completions, envs):
+            solution = env.task_config['answer']  
+
+            matches = re.findall(r"<answer>(.*?)</answer>", completion, re.DOTALL)
+            
+            if not matches:  
+                scores.append(0.0)
+                continue
+
+            extracted = matches[-1].strip()
+
+            correct = False
+            for s in solution:
+                if s.lower() in extracted.lower():
+                    correct = True
+                    break
+
+            if correct:
+                scores.append(1.0)
+            else:
+                scores.append(0.5)
+
+        return scores
+

MemGen-main/data/utils/code_utils.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+from typing import List, Tuple, Any, Optional
+import re
+import multiprocessing
+from multiprocessing.connection import Connection
+
+ExecuteResult = Tuple[bool, str, Tuple[bool]]
+
+
+def extract_python_code(text_string: str) -> List[str]:
+    code_blocks = re.findall(r"```python(.*?)```", text_string, re.DOTALL)
+    if not code_blocks:
+        code_blocks = [text_string]
+
+    results = []
+    for block in code_blocks:
+        imports = re.findall(r"^(?:from\s+\S+\s+import\s+\S+|import\s+\S+.*)$", block, re.MULTILINE)
+
+        funcs = re.findall(r"(def\s+\w+\(.*?:[\s\S]*?)(?=^def\s|\Z)", block.strip(), re.MULTILINE)
+
+        if imports:
+            import_block = "\n".join(imports)
+            if funcs:
+                funcs = [import_block] + funcs
+            else:
+                funcs = [import_block]
+
+        results.extend(funcs)
+
+    return results
+
+def rename_function(function: str, function_name: str) -> str:
+    """
+    Replace the name of the first function in `answer` with `function_name`.
+    Only modifies the function name, keeps everything else intact.
+    """
+    pattern = r"def\s+(\w+)\s*\("
+
+    new_answer = re.sub(pattern, f"def {function_name}(", function, count=1)
+    return new_answer
+
+
+def _exec_code_and_capture(code: str, conn: Connection, work_dir: Optional[str] = None):
+    try:
+        if work_dir is not None:
+            os.makedirs(work_dir, exist_ok=True)
+            os.chdir(work_dir)
+
+        local_ns = {}
+        exec(code, local_ns)
+
+        for name, func in local_ns.items():
+            if callable(func) and name.startswith("test_"):
+                func()
+        conn.send(True)
+    except Exception as e:
+        conn.send(e)
+    finally:
+        conn.close()
+
+
+class PyExecutor:
+
+    def _run_with_timeout(self, code: str, timeout: int, work_dir: Optional[str] = "./code_stuff") -> Any:
+        parent_conn, child_conn = multiprocessing.Pipe()
+        p = multiprocessing.Process(
+            target=_exec_code_and_capture,
+            args=(code, child_conn, work_dir)
+        )
+        
+        p.start()
+        p.join(timeout)
+
+        if p.is_alive():
+            p.kill()
+            p.join()
+            raise TimeoutError("Test execution timed out")
+
+        if parent_conn.poll():
+            result = parent_conn.recv()
+            if isinstance(result, Exception):
+                raise result
+            return result
+        else:
+            raise RuntimeError("Child process terminated unexpectedly without sending a result.")
+
+    def execute(self, func: str, tests: List[str], timeout: int = 5, verbose: bool = True) -> ExecuteResult:
+        success_tests = []
+        failed_tests = []
+        is_passing = True
+
+        for test_code in tests:
+            cleaned_test = re.sub(r"^\s*from\s+solution\s+import\s+\w+\s*", "", test_code, flags=re.MULTILINE)
+            code_to_run = func + "\n" + cleaned_test
+            try:
+                self._run_with_timeout(code_to_run, timeout)
+                success_tests.append(test_code)
+            except Exception as e:
+                failed_tests.append(f"{test_code}  # output: {e}")
+                is_passing = False
+
+        state = tuple(test in success_tests for test in tests)
+        feedback = (
+            "Tests passed:\n" + "\n".join(success_tests)
+            + "\n\nTests failed:\n" + "\n".join(failed_tests)
+        )
+        return is_passing, feedback, state
+
+    def evaluate(self, name: str, func: str, test: str, timeout: int = 5) -> bool:
+        cleaned_test = re.sub(r"^\s*from\s+solution\s+import\s+\w+\s*", "", test, flags=re.MULTILINE)
+        code_to_run = func + "\n" + cleaned_test
+        try:
+            self._run_with_timeout(code_to_run, timeout)
+            return True
+        except Exception:
+            return False
+        
+    def check_code_report(self, completions: list[str], tests: list[str], timeout: int = 5) -> tuple[list[str], list[float]]:
+        def extract_failed_tests(text: str) -> str:
+            match = re.search(r"Tests failed:\s*(.*)", text, re.DOTALL)
+            return match.group(1).strip() if match else ""
+        
+        def extract_correct_function_name(text: str) -> str:
+            match = re.search(r"from\s+solution\s+import\s+([a-zA-Z_]\w*)", text)
+            return match.group(1) if match else ""
+
+        reports = []
+        avg_scores = [] 
+
+        for completion, test_code_str in zip(completions, tests):
+            func_blocks = extract_python_code(completion.strip())
+            collected_answer = '\n'.join(func_blocks)
+
+            correct_function_name = extract_correct_function_name(test_code_str)
+            if correct_function_name != "":
+                collected_answer = rename_function(collected_answer, correct_function_name)
+
+            test_block = extract_python_code(test_code_str.strip())
+            test_list = [test_block[0] + "\n\n" + block for block in test_block[1:]]
+
+            report_lines = []
+            success_examples = 0
+
+            for test in test_list:
+                func_name_match = re.search(r"def\s+(test_\w+)\s*\(", test)
+                func_name = func_name_match.group(1) if func_name_match else "unknown_test"
+
+                is_passing, feedback, _ = self.execute(collected_answer, [test], timeout=timeout)
+
+                if is_passing:
+                    success_examples += 1
+                    report_lines.append(f"✅ Test passed for '{func_name}'")
+                else:
+                    report_lines.append(f"❌ Test failed for '{func_name}': \n{extract_failed_tests(feedback)}")
+            
+            if len(test_list) != 0:
+                avg_score = success_examples / len(test_list)
+            else:
+                avg_score = 1.0 
+            avg_scores.append(avg_score)  
+            report_lines.append(f"\nAverage correctness: {avg_score:.2f}")
+
+            reports.append("\n".join(report_lines))
+
+        return reports, avg_scores
+
+        

MemGen-main/data/utils/dynamic_padding.py

@@ -0,0 +1,78 @@
+import torch
+from transformers import PreTrainedTokenizerBase 
+from typing import Dict, List, Any
+
+class DynamicPaddingDataCollater:
+    def __init__(self, tokenizer: PreTrainedTokenizerBase):
+
+        self.tokenizer = tokenizer
+
+        if tokenizer.pad_token_id is None:
+            print("Warning: Tokenizer does not have a pad_token_id. Using 0 for input_ids and attention_mask padding.")
+            self.padding_value_input = 0
+        else:
+            self.padding_value_input = tokenizer.pad_token_id
+
+        # labels 的填充值
+        self.padding_value_label = tokenizer.pad_token_id
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
+
+        processed_features = []
+        for feature in features:
+            input_ids = feature["input_ids"]
+            completion_mask = feature["completion_mask"]
+
+            prompt_ids = [token for token, is_completion in zip(input_ids, completion_mask) if not is_completion]
+
+            label_ids = [token for token, is_completion in zip(input_ids, completion_mask) if is_completion]
+
+            processed_features.append({
+                "prompt_ids": prompt_ids,
+                "label_ids": label_ids,
+
+                "original": feature 
+            })
+
+        max_prompt_len = max(len(f["prompt_ids"]) for f in processed_features)
+        max_label_len = max(len(f["label_ids"]) for f in processed_features)
+
+        padded_prompt_ids = []
+        padded_input_attention_mask = []
+        padded_label_ids = []
+        padded_labels_attention_mask = []
+
+        for feature in processed_features:
+
+            prompt_ids = feature["prompt_ids"]
+            label_ids = feature["label_ids"]
+            
+
+            num_input_pads = max_prompt_len - len(prompt_ids)
+            padded_prompt_ids.append([self.padding_value_input] * num_input_pads + prompt_ids)
+
+            input_attention_mask = [1] * len(prompt_ids)
+            num_input_mask_pads = max_prompt_len - len(input_attention_mask)
+            padded_input_attention_mask.append([0] * num_input_mask_pads + input_attention_mask)
+
+            num_label_pads = max_label_len - len(label_ids)
+            padded_label_ids.append(label_ids + [self.padding_value_label] * num_label_pads)
+            
+            labels_attention_mask = [1] * len(label_ids)
+            num_label_mask_pads = max_label_len - len(labels_attention_mask)
+            padded_labels_attention_mask.append(labels_attention_mask + [0] * num_label_mask_pads)
+        
+        batch = {
+            "prompt_ids": torch.tensor(padded_prompt_ids, dtype=torch.long),
+            "prompt_attention_mask": torch.tensor(padded_input_attention_mask, dtype=torch.long),
+            "label_ids": torch.tensor(padded_label_ids, dtype=torch.long),
+            "label_attention_mask": torch.tensor(padded_labels_attention_mask, dtype=torch.long),
+        }
+        
+        batch["raw_samples"] = [f["original"] for f in processed_features]
+
+        return batch
+
+        
+
+

MemGen-main/data/utils/math_utils.py

@@ -0,0 +1,254 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Adapted from https://github.com/EleutherAI/lm-evaluation-harness/blob/main/lm_eval/tasks/hendrycks_math/utils.py
+
+
+def compute_score(completion, ground_truth) -> float:
+    retval = 0.0
+    try:
+        # string_in_last_boxed = last_boxed_only_string(solution_str)
+        string_in_first_boxed = first_boxed_only_string(completion)
+        ground_truth_in_last_boxed = last_boxed_only_string(ground_truth)
+        if string_in_first_boxed is not None:
+            answer = remove_boxed(string_in_first_boxed)
+            ground_truth = remove_boxed(ground_truth_in_last_boxed)
+            if is_equiv(answer, ground_truth):
+                retval = 1.0
+    except Exception as e:
+        print(e)
+
+    return retval
+
+
+# string normalization from https://github.com/EleutherAI/lm-evaluation-harness/blob/master/lm_eval/tasks/hendrycks_math.py
+def is_equiv(str1, str2, verbose=False):
+    if str1 is None and str2 is None:
+        print("WARNING: Both None")
+        return True
+    if str1 is None or str2 is None:
+        return False
+
+    try:
+        ss1 = strip_string(str1)
+        ss2 = strip_string(str2)
+        if verbose:
+            print(ss1, ss2)
+        return ss1 == ss2
+    except Exception:
+        return str1 == str2
+
+
+def remove_boxed(s):
+    if "\\boxed " in s:
+        left = "\\boxed "
+        assert s[: len(left)] == left
+        return s[len(left) :]
+
+    left = "\\boxed{"
+
+    assert s[: len(left)] == left
+    assert s[-1] == "}"
+
+    return s[len(left) : -1]
+
+def first_boxed_only_string(string):
+    if "\\boxed " in string:
+        return "\\boxed " + string.split("\\boxed ")[1].split("$")[0]
+
+    idx = string.find("\\boxed")
+    if idx < 0:
+        idx = string.find("\\fbox")
+        if idx < 0:
+            return None
+
+    i = idx
+    right_brace_idx = None
+    num_left_braces_open = 0
+    while i < len(string):
+        if string[i] == "{":
+            num_left_braces_open += 1
+        if string[i] == "}":
+            num_left_braces_open -= 1
+            if num_left_braces_open == 0:
+                right_brace_idx = i
+                break
+        i += 1
+
+    retval = None if right_brace_idx is None else string[idx : right_brace_idx + 1]
+
+    return retval
+
+
+def last_boxed_only_string(string):
+    idx = string.rfind("\\boxed")
+    if "\\boxed " in string:
+        return "\\boxed " + string.split("\\boxed ")[-1].split("$")[0]
+    if idx < 0:
+        idx = string.rfind("\\fbox")
+        if idx < 0:
+            return None
+
+    i = idx
+    right_brace_idx = None
+    num_left_braces_open = 0
+    while i < len(string):
+        if string[i] == "{":
+            num_left_braces_open += 1
+        if string[i] == "}":
+            num_left_braces_open -= 1
+            if num_left_braces_open == 0:
+                right_brace_idx = i
+                break
+        i += 1
+
+    retval = None if right_brace_idx is None else string[idx : right_brace_idx + 1]
+
+    return retval
+
+
+def fix_fracs(string):
+    substrs = string.split("\\frac")
+    new_str = substrs[0]
+    if len(substrs) > 1:
+        substrs = substrs[1:]
+        for substr in substrs:
+            new_str += "\\frac"
+            if substr[0] == "{":
+                new_str += substr
+            else:
+                try:
+                    assert len(substr) >= 2
+                except:  # noqa: E722
+                    return string
+                a = substr[0]
+                b = substr[1]
+                if b != "{":
+                    if len(substr) > 2:
+                        post_substr = substr[2:]
+                        new_str += "{" + a + "}{" + b + "}" + post_substr
+                    else:
+                        new_str += "{" + a + "}{" + b + "}"
+                else:
+                    if len(substr) > 2:
+                        post_substr = substr[2:]
+                        new_str += "{" + a + "}" + b + post_substr
+                    else:
+                        new_str += "{" + a + "}" + b
+    string = new_str
+    return string
+
+
+def fix_a_slash_b(string):
+    if len(string.split("/")) != 2:
+        return string
+    a = string.split("/")[0]
+    b = string.split("/")[1]
+    try:
+        a = int(a)
+        b = int(b)
+        assert string == "{}/{}".format(a, b)
+        new_string = "\\frac{" + str(a) + "}{" + str(b) + "}"
+        return new_string
+    except:  # noqa: E722
+        return string
+
+
+def remove_right_units(string):
+    # "\\text{ " only ever occurs (at least in the val set) when describing units
+    if "\\text{ " in string:
+        splits = string.split("\\text{ ")
+        assert len(splits) == 2
+        return splits[0]
+    else:
+        return string
+
+
+def fix_sqrt(string):
+    if "\\sqrt" not in string:
+        return string
+    splits = string.split("\\sqrt")
+    new_string = splits[0]
+    for split in splits[1:]:
+        if split[0] != "{":
+            a = split[0]
+            new_substr = "\\sqrt{" + a + "}" + split[1:]
+        else:
+            new_substr = "\\sqrt" + split
+        new_string += new_substr
+    return new_string
+
+
+def strip_string(string):
+    # linebreaks
+    string = string.replace("\n", "")
+
+    # remove inverse spaces
+    string = string.replace("\\!", "")
+
+    # replace \\ with \
+    string = string.replace("\\\\", "\\")
+
+    # replace tfrac and dfrac with frac
+    string = string.replace("tfrac", "frac")
+    string = string.replace("dfrac", "frac")
+
+    # remove \left and \right
+    string = string.replace("\\left", "")
+    string = string.replace("\\right", "")
+
+    # Remove circ (degrees)
+    string = string.replace("^{\\circ}", "")
+    string = string.replace("^\\circ", "")
+
+    # remove dollar signs
+    string = string.replace("\\$", "")
+
+    # remove units (on the right)
+    string = remove_right_units(string)
+
+    # remove percentage
+    string = string.replace("\\%", "")
+    string = string.replace("\%", "")  # noqa: W605
+
+    # " 0." equivalent to " ." and "{0." equivalent to "{." Alternatively, add "0" if "." is the start of the string
+    string = string.replace(" .", " 0.")
+    string = string.replace("{.", "{0.")
+    # if empty, return empty string
+    if len(string) == 0:
+        return string
+    if string[0] == ".":
+        string = "0" + string
+
+    # to consider: get rid of e.g. "k = " or "q = " at beginning
+    if len(string.split("=")) == 2 and len(string.split("=")[0]) <= 2:
+        string = string.split("=")[1]
+
+    # fix sqrt3 --> sqrt{3}
+    string = fix_sqrt(string)
+
+    # remove spaces
+    string = string.replace(" ", "")
+
+    # \frac1b or \frac12 --> \frac{1}{b} and \frac{1}{2}, etc. Even works with \frac1{72} (but not \frac{72}1).
+    # Also does a/b --> \\frac{a}{b}
+    string = fix_fracs(string)
+
+    # manually change 0.5 --> \frac{1}{2}
+    if string == "0.5":
+        string = "\\frac{1}{2}"
+
+    # NOTE: X/Y changed to \frac{X}{Y} in dataset, but in simple cases fix in case the model output is X/Y
+    string = fix_a_slash_b(string)
+
+    return string

MemGen-main/data/utils/processor.py

@@ -0,0 +1,39 @@
+from typing import Dict
+
+def add_eos(example, eos_token):
+    """在 labels 部分末尾添加 eos token
+    """
+    if "text" in example and not example["text"].endswith(eos_token):  
+        example["text"] = example["text"] + eos_token
+    elif "completion" in example and not example["completion"].endswith(eos_token):
+        example["completion"] = example["completion"] + eos_token
+    return example
+
+def tokenize(example, processing_class) -> Dict:
+
+    output = dict(example)
+    prompt_ids = processing_class(
+        text=example["prompt"], add_special_tokens=False
+    )["input_ids"]
+    completion_ids = processing_class(
+        text=example["completion"], add_special_tokens=False
+    )["input_ids"]
+    input_ids = prompt_ids + completion_ids  
+    
+    # Create a completion mask
+    completion_mask = [0] * len(prompt_ids) + [1] * len(completion_ids)
+    output["input_ids"] = input_ids
+    output["completion_mask"] = completion_mask
+
+    return output
+
+def tokenize_instruction_example(example: Dict, processing_class) -> Dict:
+    eos_token = processing_class.eos_token
+    eos_example = add_eos(example, eos_token)
+    tokenized_example = tokenize(eos_example, processing_class)
+    
+    return tokenized_example
+
+
+def tokenize_conversation_example(example: Dict, processing_class) -> Dict:
+    ...

MemGen-main/data/utils/retrieval_utils.py

@@ -0,0 +1,43 @@
+from typing import List
+import requests
+
+class Retriever:
+
+    def __init__(self):
+        self.config = {
+            "search_url": "http://127.0.0.1:8001/retrieve",
+            "topk": 3
+        }
+
+    def batch_search(self, queries: List[str] = None) -> List[str]:
+        """
+        Batchified search for queries.
+        Args:
+            queries: queries to call the search engine
+        Returns:
+            search results which is concatenated into a string
+        """
+        results = self._batch_search(queries)['result']
+        
+        return [self._passages2string(result) for result in results]
+
+    def _batch_search(self, queries):
+        
+        payload = {
+            "queries": queries,
+            "topk": self.config["topk"],
+            "return_scores": True
+        }
+        
+        return requests.post(self.config["search_url"], json=payload).json()
+
+    def _passages2string(self, retrieval_result):
+        format_reference = ''
+        for idx, doc_item in enumerate(retrieval_result):
+            
+            content = doc_item['document']['contents']
+            title = content.split("\n")[0]
+            text = "\n".join(content.split("\n")[1:])
+            format_reference += f"Doc {idx+1}(Title: {title}) {text}\n"
+
+        return format_reference

MemGen-main/data/utils/search_utils.py

@@ -0,0 +1,70 @@
+from typing import Optional, Union
+from langchain.docstore.document import Document
+import wikipedia
+
+class LangChainWiki:
+
+    def __init__(self) -> None:
+        self.document: Optional[Document] = None
+        self.lookup_str = ""
+        self.lookup_index = 0
+
+    def search(self, search: str) -> Union[str, Document]:
+        def _try_search(term: str) -> Union[str, Document]:
+            try:
+                page_content = wikipedia.page(search).content 
+                url = wikipedia.page(search).url 
+                result: Union[str, Document] = Document( page_content=page_content, metadata={"page": url} )
+                return result
+            except wikipedia.PageError:
+                return f"Could not find [{term}]. Similar: {wikipedia.search(term)}"
+            except wikipedia.DisambiguationError:
+                return f"Could not find [{term}]. Similar: {wikipedia.search(term)}"
+            except Exception:
+                return f"Could not find [{term}]. Similar: {wikipedia.search(term)}"
+
+        result = _try_search(search)
+
+        if isinstance(result, str) and "Similar:" in result:
+            try:
+                similar = wikipedia.search(search)
+                if similar:
+                    fallback = similar[0]
+                    print(f"[INFO] Falling back to similar term: {fallback}")
+                    result = _try_search(fallback)
+            except Exception as e:
+                print(f"[ERROR] Could not fetch similar terms: {e}")
+
+        if isinstance(result, Document):
+            self.document = result
+            return self._sumary
+        else:
+            self.document = None
+            return result
+
+    def lookup(self, term: str):
+        if self.document is None:
+            raise ValueError("Cannot lookup without a successful search first")
+        if term.lower() != self.lookup_str:
+            self.lookup_str = term.lower()
+            self.lookup_index = 0
+        else:
+            self.lookup_index += 1
+        lookups = [p for p in self._paragraphs if self.lookup_str in p.lower()]
+        if len(lookups) == 0:
+            return "No Results"
+        elif self.lookup_index >= len(lookups):
+            return "No More Results"
+        else:
+            result_prefix = f"(Result {self.lookup_index + 1}/{len(lookups)})"
+            return f"{result_prefix} {lookups[self.lookup_index]}"
+
+    @property
+    def _sumary(self) -> str:
+        return self._paragraphs[0]
+
+    @property
+    def _paragraphs(self) -> list[str]:
+        if self.document is None:
+            raise ValueError("Cannot get paragraphs without a document")
+        return self.document.page_content.split("\n\n")

MemGen-main/interactions/base_interaction.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+import logging
+from typing import Optional
+
+from transformers import GenerationConfig
+
+from interactions.tensor_utils import TensorHelper, TensorConfig
+
+
+@dataclass
+class InteractionConfig:
+    max_turns: int = 1
+    max_start_length: int = 1024   
+    max_prompt_length: int = 4096   
+    max_response_length: int = 512
+    max_obs_length: int = 512
+    # do_sample: bool = False
+    temperature: float = 1.0  
+    batch_size: int = 8
+    output_dir: Optional[str] = None
+    weaver_do_sample: bool = False
+    trigger_do_sample: bool = False
+
+@dataclass
+class InteractionDataProto:
+    batch: dict = field(default_factory=dict)
+    no_tensor_batch: dict = field(default_factory=dict)
+
+class InteractionManager(ABC):
+    
+    def __init__(
+        self,
+        tokenizer,
+        actor_rollout_wg,
+        config: InteractionConfig,
+        is_validation: bool = False,
+    ):
+        self.tokenizer = tokenizer
+        self.tokenizer.padding_side = "left" 
+        self.actor_rollout_wg = actor_rollout_wg
+        self.config = config
+        self.is_validation = is_validation
+        
+        assert tokenizer.pad_token_id is not None
+        self.tensor_fn = TensorHelper(TensorConfig(
+            pad_token_id=tokenizer.pad_token_id,
+            max_prompt_length=config.max_prompt_length,
+            max_obs_length=config.max_obs_length,
+            max_start_length=config.max_start_length
+        ))
+
+        # generation configs for agent
+        self.generation_config = GenerationConfig(
+            max_new_tokens=self.config.max_response_length,
+            temperature=self.config.temperature,
+            pad_token_id=self.tokenizer.pad_token_id,
+            eos_token_id=self.tokenizer.eos_token_id
+        )
+        self.generation_config.weaver_do_sample = self.config.weaver_do_sample
+        self.generation_config.trigger_do_sample = self.config.trigger_do_sample
+
+        logging.info(f"Weaver do sample: {self.generation_config.weaver_do_sample}, Trigger do sample: {self.generation_config.trigger_do_sample}")
+    
+    @abstractmethod
+    def run_agent_loop(self, gen_batch: InteractionDataProto) -> InteractionDataProto:
+        ...

MemGen-main/interactions/multiturn_interaction.py

@@ -0,0 +1,263 @@
+import torch
+from typing import Dict, List, Tuple
+import copy
+
+from interactions.base_interaction import (
+    InteractionDataProto,
+    InteractionConfig, 
+    InteractionManager
+)
+
+
+class MultiTurnInteractionManager(InteractionManager):
+    def __init__(
+        self,
+        tokenizer,
+        actor_rollout_wg,
+        config: InteractionConfig,
+        is_validation: bool = False,
+    ):
+        super().__init__(
+            tokenizer, actor_rollout_wg, config, is_validation
+        )
+
+    def _batch_tokenize(self, responses: List[str]) -> torch.Tensor:
+        """Tokenize a batch of responses."""
+        return self.tokenizer(   
+            responses, 
+            add_special_tokens=False, 
+            return_tensors='pt', 
+            padding="longest"
+        )['input_ids']
+    
+    def _build_chat_history(self, rollings: Dict) -> List[Dict]:
+
+        init_prompts = rollings.get("init_prompts")
+        if init_prompts is None:
+            raise ValueError("")
+        
+        inter_histories = rollings.get("inter_histories")
+        if inter_histories is None:
+            raise ValueError("")
+        
+        chat_histories: List[List[Dict]] = []
+        for init_prompt, inter_history in zip(init_prompts, inter_histories):
+            chat_histories.append(init_prompt + inter_history)
+
+        return chat_histories
+    
+    def _update_interaction_history(self, rollings: InteractionDataProto, responses: List[str], observations: List[str]) -> List[List[Dict]]:
+
+        inter_histories = copy.deepcopy(rollings.no_tensor_batch.get("inter_histories"))
+        assert len(inter_histories) == len(responses) == len(observations)
+        for inter_history, response, observation in zip(inter_histories, responses, observations):
+            assistant_info = {"role": "assistant", "content": response}
+            user_info = {"role": "user", "content": observation}
+            
+            inter_history.append(assistant_info)
+            inter_history.append(user_info)
+        
+        return inter_histories
+    
+    def _postprocess_responses(self, responses: torch.Tensor, envs: List) -> torch.Tensor:
+
+        responses_str = self.tokenizer.batch_decode(
+            responses, 
+            skip_special_tokens=True
+        )
+
+        processed_responses_str = []
+        for r, env in zip(responses_str, envs):
+            processed_r = env.preprocess_action(r)
+            processed_responses_str.append(processed_r)
+
+        responses = self._batch_tokenize(processed_responses_str)
+        return responses, processed_responses_str
+
+
+    def _example_level_pad(
+        self, responses_ids: torch.Tensor, responses_str: List[str], active_mask: torch.Tensor
+    ) -> Tuple[torch.Tensor, List[str]]:
+
+        assert active_mask.sum() == responses_ids.shape[0]
+        # Create masked responses tensor
+        batch_size = active_mask.shape[0]
+        seq_len = responses_ids.shape[1]
+        padded_responses = torch.full(
+            (batch_size, seq_len), self.tokenizer.pad_token_id,
+            dtype=responses_ids.dtype, device=responses_ids.device
+        )
+        padded_responses[active_mask] = responses_ids   
+        
+        # Create masked response strings
+        padded_responses_str = [""] * batch_size
+        
+        s = 0
+        for i, is_active in enumerate(active_mask):
+            if is_active:
+                padded_responses_str[i] = responses_str[s]
+                s += 1
+                
+        return padded_responses, padded_responses_str
+
+    def run_agent_loop(self, gen_batch: InteractionDataProto) -> InteractionDataProto:
+        """Run main LLM generation loop (conversation format)."""
+        assert "init_prompts" in gen_batch.no_tensor_batch
+        assert "envs" in gen_batch.no_tensor_batch
+        batch_size = len(gen_batch.no_tensor_batch["init_prompts"])
+
+        rollings = gen_batch   
+        rollings.no_tensor_batch["inter_histories"] = [[] for _ in range(batch_size)]
+
+        active_mask = torch.ones(batch_size, dtype=torch.bool)
+        active_num_list = [active_mask.sum().item()]
+
+        for step in range(self.config.max_turns):
+            if not active_mask.sum():   
+                break            
+
+            mask_list = active_mask.tolist()  
+            rollings_active = {
+                k: [item for item, keep in zip(v, mask_list) if keep]
+                for k, v in rollings.no_tensor_batch.items()
+            }
+            # use tokenizer to add chat template and encode text to tokens: input_ids, attention_mask
+            messages = self._build_chat_history(rollings_active)
+            self.tokenizer.padding_side = "left"
+            inputs = self.tokenizer.apply_chat_template(
+                messages, tokenize=True, 
+                add_generation_prompt=True, 
+                padding=True, return_tensors="pt", return_dict=True
+            )
+
+            # agent rollout
+            gen_output = self.actor_rollout_wg.generate(
+                input_ids=inputs["input_ids"],
+                attention_mask=inputs["attention_mask"],
+                generation_config=self.generation_config,
+            ).to("cpu")
+
+            # postprocess
+            prompt_len = inputs["input_ids"].size(1)
+            responses = gen_output[:, prompt_len:]
+            responses = self.tensor_fn.erase_after_first_eos(responses, self.tokenizer.eos_token_id)
+            responses_ids, responses_str = self._postprocess_responses(responses, rollings_active["envs"])
+            all_responses_ids, all_responses_str = self._example_level_pad(responses_ids, responses_str, active_mask)
+
+            next_obs, dones = self._execute_predictions(rollings, all_responses_str, active_mask)
+            processed_obs = self._postprocess_observations(next_obs)
+            
+            # post process interaction states
+            curr_active_mask = torch.tensor([not done for done in dones], dtype=torch.bool)
+            active_mask = active_mask * curr_active_mask
+            active_num_list.append(active_mask.sum().item())
+
+            interaction_histories = self._update_interaction_history(rollings, all_responses_str, processed_obs)
+            rollings.no_tensor_batch["inter_histories"] = interaction_histories
+  
+        # build final outputs
+        final_outputs = self._build_final_outputs(rollings)
+        return final_outputs
+
+    def _execute_predictions(self, rollings: InteractionDataProto, responses: List[str], active_mask: torch.Tensor) -> Tuple[List[str], List[str]]:
+        observations = []
+        dones = []
+        for response, env, is_active in zip(responses, rollings.no_tensor_batch["envs"], active_mask):
+            if is_active:
+                observation, _, done = env.step(response)
+            else:   
+                observation = ""
+                done = True
+            observations.append(observation)
+            dones.append(done)
+
+        return observations, dones
+
+    
+    def _postprocess_observations(self, observations: List[str]) -> List[str]:
+        self.tokenizer.padding_side = "right" 
+        next_obs_ids = self._batch_tokenize(observations)
+
+        max_len = self.config.max_obs_length
+        if next_obs_ids.shape[1] > max_len:
+            extra_text = "..."
+            extra_ids = self.tokenizer.encode(
+                extra_text, add_special_tokens=False, return_tensors="pt"
+            ).to(next_obs_ids.device)
+            extra_len = extra_ids.shape[1]
+
+            new_obs_ids = []
+            for row in next_obs_ids:
+                valid_len = (row != self.tokenizer.pad_token_id).sum().item()
+
+                if valid_len > max_len:  
+                    truncated = row[: max_len - extra_len]
+                    new_row = torch.cat([truncated, extra_ids.squeeze(0)], dim=0)
+                else:
+                    new_row = row[:max_len]
+
+                new_obs_ids.append(new_row.unsqueeze(0))
+
+            next_obs_ids = torch.cat(new_obs_ids, dim=0)
+            observations = self.tokenizer.batch_decode(next_obs_ids, skip_special_tokens=True)
+
+        return observations
+
+    def _build_final_outputs(self, rollings: InteractionDataProto) -> InteractionDataProto:
+
+        init_prompts: List[List[Dict]] = rollings.no_tensor_batch["init_prompts"]
+        inter_histories: List[List[Dict]] = rollings.no_tensor_batch["inter_histories"]
+        
+        output = InteractionDataProto()
+
+        output.no_tensor_batch["inter_histories"] = [
+            prompt + inter for prompt, inter in zip(init_prompts, inter_histories)
+        ]
+        
+        # ---------- prompts ----------
+        self.tokenizer.padding_side = "left"
+        prompt_ids = self.tokenizer.apply_chat_template(                
+            init_prompts, tokenize=True, 
+            add_generation_prompt=False,  
+            padding=True, return_tensors="pt", return_dict=True
+        )
+        output.batch["prompts"] = prompt_ids["input_ids"]
+        prompt_attn_mask = prompt_ids["attention_mask"]
+        
+        # ---------- responses ----------
+        self.tokenizer.padding_side = "right"
+        response_ids = self.tokenizer.apply_chat_template(                
+            inter_histories, 
+            tokenize=True, 
+            padding=True,
+            return_assistant_tokens_mask=True,
+            add_generation_prompt=False,
+            return_tensors="pt", return_dict=True
+        )
+        output.batch["responses"] = response_ids["input_ids"]
+        response_attn_mask = response_ids["attention_mask"]
+
+        completion_info_mask = response_ids["assistant_masks"]
+
+        # ---------- input_ids ----------
+        output.batch["input_ids"] = torch.cat(
+            [prompt_ids["input_ids"], response_ids["input_ids"]], dim=1
+        )
+        output.batch["attention_mask"] = torch.cat(
+            [prompt_attn_mask, response_attn_mask], dim=1
+        )
+
+        # ---------- info_mask ----------
+        prompt_info_mask = torch.zeros(
+            prompt_ids["input_ids"].shape, 
+            dtype=completion_info_mask.dtype, 
+            device=completion_info_mask.device
+        )
+
+        output.batch["info_mask"] = torch.cat(
+            [prompt_info_mask, completion_info_mask], dim=1
+        )
+        
+        self.tokenizer.padding_side = "left"
+
+        return output

MemGen-main/interactions/singleturn_interaction.py

@@ -0,0 +1,144 @@
+import torch
+from typing import Dict, List
+
+from interactions.base_interaction import (
+    InteractionConfig, 
+    InteractionManager,
+    InteractionDataProto
+)
+
+
+class SingleTurnInteractionManager(InteractionManager):
+    def __init__(
+        self,
+        tokenizer,
+        actor_rollout_wg,
+        config: InteractionConfig,
+        is_validation: bool = False,
+    ):
+        super().__init__(
+            tokenizer, actor_rollout_wg, config, is_validation
+        )
+    
+    def _batch_tokenize(self, responses: List[str]) -> torch.Tensor:
+        """Tokenize a batch of responses."""
+        return self.tokenizer(  
+            responses, 
+            add_special_tokens=False, 
+            return_tensors='pt', 
+            padding="longest"
+        )['input_ids']    
+
+    def _info_masked_concatenate_with_padding(self, 
+        prompt: torch.Tensor, 
+        prompt_with_mask: torch.Tensor, 
+        response: torch.Tensor, 
+        info: torch.Tensor = None,
+        pad_to_left: bool = True
+    ) -> torch.Tensor:
+        """Concatenate tensors and handle padding. Additionally, create a mask (info_mask) to cover the information block if it exists."""
+        pad_id = self.tokenizer.pad_token_id
+        tensors = [prompt, response]
+        tensors_with_mask = [prompt_with_mask, response]
+        if info is not None:
+            tensors.append(info)
+            info_mask = torch.full(info.size(), pad_id, dtype=info.dtype, device=info.device) # information mask
+            tensors_with_mask.append(info_mask)
+        
+        concatenated = torch.cat(tensors, dim=1)
+        concatenated_with_info = torch.cat(tensors_with_mask, dim=1)
+        mask = concatenated != pad_id if pad_to_left else concatenated == pad_id
+        sorted_indices = mask.to(torch.int64).argsort(dim=1, stable=True)
+        padded_tensor = concatenated.gather(1, sorted_indices)
+        padded_tensor_with_info = concatenated_with_info.gather(1, sorted_indices)
+
+        return padded_tensor, padded_tensor_with_info
+    
+    def _update_right_side(
+        self, right_side: Dict, 
+        cur_responses: torch.Tensor,
+        next_obs_ids: torch.Tensor = None
+    ) -> Dict:
+        """Update right side state."""
+        if next_obs_ids != None: 
+            responses, responses_with_info_mask = self._info_masked_concatenate_with_padding(
+                    right_side['responses'],
+                    right_side['responses_with_info_mask'],
+                    cur_responses,
+                    next_obs_ids, 
+                    pad_to_left=False   
+                )
+        else:
+            responses, responses_with_info_mask = self._info_masked_concatenate_with_padding(
+                    right_side['responses'],
+                    right_side['responses_with_info_mask'],
+                    cur_responses,
+                    pad_to_left=False
+                )
+        effective_len = self.tensor_fn.create_attention_mask(responses).sum(dim=1).max()
+        max_len = min(self.config.max_prompt_length, effective_len)
+        
+        return {'responses': responses[:, :max_len], 'responses_with_info_mask': responses_with_info_mask[:, :max_len]}
+    
+    def run_agent_loop(self, gen_batch: InteractionDataProto) -> InteractionDataProto:
+        
+        initial_input_ids = gen_batch.batch["input_ids"]
+        original_left_side = {'input_ids': initial_input_ids[:, -self.config.max_start_length:]}
+        original_right_side = {'responses': initial_input_ids[:, []], 'responses_with_info_mask': initial_input_ids[:, []]}
+
+        # postprocess model inputs
+        rollings = gen_batch
+        rollings.batch = self.tensor_fn.cut_to_effective_len(
+            rollings.batch,
+            keys=['input_ids', 'attention_mask']    
+        )
+        rollings_active = {
+            k: v for k, v in rollings.batch.items()
+        }  
+
+        # model generation
+        gen_output = self.actor_rollout_wg.generate(
+            rollings_active["input_ids"], 
+            rollings_active["attention_mask"], 
+            generation_config=self.generation_config,
+        )
+        responses_ids = gen_output[:, rollings_active["input_ids"].size(1):]
+        responses_ids = self.tensor_fn.erase_after_first_eos(responses_ids, self.tokenizer.eos_token_id)
+        
+        # update right side
+        original_right_side = self._update_right_side(original_right_side, responses_ids, next_obs_ids=None)
+        
+        # construct final output
+        return self._compose_final_output(original_left_side, original_right_side)
+    
+    def _compose_final_output(
+        self, left_side: Dict,
+        right_side: Dict,
+    ) -> InteractionDataProto:
+        """Compose final generation output."""
+        
+        final_output_batch = right_side.copy()
+        final_output_batch['prompts'] = left_side['input_ids']
+        final_output_batch["responses"] = right_side['responses']
+        
+        # Combine input IDs: input_ids + responses
+        final_output_batch['input_ids'] = torch.cat([
+            left_side['input_ids'],
+            right_side['responses']
+        ], dim=1)
+
+        # Create attention mask
+        final_output_batch['attention_mask'] = torch.cat([
+            self.tensor_fn.create_attention_mask(left_side['input_ids']),
+            self.tensor_fn.create_attention_mask(final_output_batch['responses'])
+        ], dim=1)
+        
+        final_output_batch['info_mask'] = torch.cat([  
+            self.tensor_fn.create_attention_mask(left_side['input_ids']),
+            self.tensor_fn.create_attention_mask(final_output_batch['responses_with_info_mask'])
+        ], dim=1)
+        
+        final_output = InteractionDataProto(batch=final_output_batch)
+
+        return final_output
+        

MemGen-main/interactions/tensor_utils.py

@@ -0,0 +1,85 @@
+import torch
+from typing import Dict, Tuple, List
+from dataclasses import dataclass
+
+@dataclass
+class TensorConfig:
+    pad_token_id: int
+    max_prompt_length: int
+    max_obs_length: int
+    max_start_length: int
+
+class TensorHelper:
+    def __init__(self, config: TensorConfig):
+        self.config = config
+
+    def cut_to_effective_len(self, tensor_dict: Dict[str, torch.Tensor], 
+                            keys: List[str], cut_left: bool = True) -> Dict[str, torch.Tensor]:
+        """Cut tensors to their effective length based on attention mask."""
+        effective_len = tensor_dict['attention_mask'].sum(dim=1).max()
+        result = tensor_dict.copy()
+        
+        for key in keys:
+            if cut_left:  # 裁剪左侧
+                result[key] = tensor_dict[key][:, -effective_len:]
+            else:
+                result[key] = tensor_dict[key][:, :effective_len]
+        return result
+
+    def convert_pad_structure(self, tensor: torch.Tensor, pad_to_left: bool = True) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Convert padding structure and return sorted tensor with indices."""
+        mask = tensor != self.config.pad_token_id if pad_to_left else tensor == self.config.pad_token_id
+        sorted_indices = mask.to(torch.int64).argsort(dim=1, stable=True)
+        return tensor.gather(1, sorted_indices), sorted_indices
+
+    def create_attention_mask(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """Create attention mask from input ids."""
+        return torch.where(input_ids != self.config.pad_token_id, 1, 0)
+
+    def create_position_ids(self, attention_mask: torch.Tensor) -> torch.Tensor:
+        """Create position ids from attention mask."""
+        return (torch.cumsum(attention_mask, dim=1) - 1) * attention_mask
+
+    def concatenate_with_padding(
+        self, tensors: List[torch.Tensor], 
+        pad_to_left: bool = True
+    )-> torch.Tensor:
+        """Concatenate tensors and handle padding."""
+        concatenated = torch.cat(tensors, dim=1)
+        padded_tensor, _ = self.convert_pad_structure(concatenated, pad_to_left)
+        return padded_tensor
+
+    def example_level_pad(
+        self, responses: torch.Tensor, 
+        responses_str: List[str], 
+        active_mask: torch.Tensor
+    ) -> Tuple[torch.Tensor, List[str]]:
+        assert active_mask.sum() == responses.shape[0]
+        # Create masked responses tensor
+        batch_size = active_mask.shape[0]
+        seq_len = responses.shape[1]
+        padded_responses = torch.full(
+            (batch_size, seq_len), self.config.pad_token_id,
+            dtype=responses.dtype, device=responses.device
+        )
+        padded_responses[active_mask] = responses
+        
+        # Create masked response strings
+        padded_responses_str = [""] * batch_size
+        
+        s = 0
+        for i, is_active in enumerate(active_mask):
+            if is_active:
+                padded_responses_str[i] = responses_str[s]
+                s += 1
+                
+        return padded_responses, padded_responses_str
+
+    def erase_after_first_eos(self, completion_ids: torch.Tensor, eos_token_id: int) -> torch.Tensor:
+        is_eos_mask = (completion_ids == eos_token_id)
+        first_eos_indices = torch.argmax(is_eos_mask.int(), dim=1)
+        seq_len = completion_ids.size(1)
+        col_indices = torch.arange(seq_len, device=completion_ids.device)
+        mask_to_replace = (col_indices > first_eos_indices.unsqueeze(1)) & is_eos_mask.any(dim=1).unsqueeze(1)
+        completion_ids[mask_to_replace] = eos_token_id
+        return completion_ids

MemGen-main/memgen/__init__.py

@@ -0,0 +1,7 @@
+from .model.modeling_memgen import MemGenModel
+from .runner import MemGenRunner
+
+__all__ = [
+    "MemGenModel",
+    "MemGenRunner",
+]

MemGen-main/memgen/model/__init__.py

@@ -0,0 +1 @@
+from memgen.model.modeling_memgen import MemGenModel

MemGen-main/memgen/model/configuration_memgen.py

@@ -0,0 +1,32 @@
+from transformers import PretrainedConfig
+from typing import Optional
+
+
+class MemGenConfig(PretrainedConfig):
+    model_type = "memgen"
+
+    def __init__(
+        self,
+        # weaver configs
+        weaver_lora_config: Optional[dict] = None,
+        prompt_latents_len: int = 0,
+        inference_latents_len: int = 0,
+        # trigger configs
+        trigger_active: bool = False,
+        trigger_lora_config: Optional[dict] = None,
+        max_prompt_aug_num: int = 1,
+        max_inference_aug_num: int = 5,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        
+        # weaver configs
+        self.weaver_lora_config = weaver_lora_config
+        self.prompt_latents_len = prompt_latents_len
+        self.inference_latents_len = inference_latents_len
+
+        # trigger configs
+        self.trigger_active = trigger_active
+        self.trigger_lora_config = trigger_lora_config
+        self.max_prompt_aug_num = max_prompt_aug_num
+        self.max_inference_aug_num = max_inference_aug_num

MemGen-main/memgen/model/modeling_memgen.py

@@ -0,0 +1,787 @@
+import logging
+import os
+import random
+from typing import Union
+
+from peft import PeftModel
+import torch
+import torch.nn as nn
+from transformers import (
+    AutoModelForCausalLM, 
+    AutoTokenizer,
+    GenerationConfig,
+    DynamicCache
+)
+from transformers.modeling_utils import PreTrainedModel
+
+from memgen.model.configuration_memgen import MemGenConfig
+from memgen.model.modeling_utils import (
+    MemGenOutputWithPast,
+    MemGenLoraSwitchMixin,
+    MemGenGenerationMixin,
+)
+from memgen.model.trigger import MemGenTrigger
+from memgen.model.weaver import MemGenWeaver
+from memgen.utils import (
+    CONVERSATION_TEMPLATE,
+    fix_model_parameters,
+    log_trainable_params
+)
+
+class MemGenModel(PreTrainedModel, MemGenLoraSwitchMixin, MemGenGenerationMixin):
+    config_class = MemGenConfig
+    INSTRUCTION_STATE = 0
+    CONVERSATION_STATE = 1
+
+    def __init__(
+        self, 
+        config: MemGenConfig, 
+        base_tokenizer,
+        reasoner_base_model: PreTrainedModel, 
+        weaver_base_model: PreTrainedModel,
+        trigger_base_model: PreTrainedModel,
+    ):   
+        super().__init__(config)
+        
+        self.config = config
+
+        # insert lora adapters into weaver and trigger
+        weaver_model_w_lora, trigger_model_w_lora = self._insert_lora_adapters(
+            weaver_base_model, config.weaver_lora_config, trigger_base_model, config.trigger_lora_config,
+        )
+
+        # use base model with lora adapters to initiate weaver and trigger
+        self.weaver = MemGenWeaver(weaver_model_w_lora, config.prompt_latents_len, config.inference_latents_len)
+        self.trigger = MemGenTrigger(trigger_model_w_lora, config.trigger_active)
+
+        # base reasoner
+        self.reasoner = reasoner_base_model
+        self.tokenizer = base_tokenizer
+        
+        # projection layers for mapping embeddings between reasoner and weaver
+        reasoner_hidden_size = reasoner_base_model.config.hidden_size
+        weaver_hidden_size = weaver_base_model.config.hidden_size
+        self.reasoner_to_weaver = nn.Linear(reasoner_hidden_size, weaver_hidden_size)  # map reasoner input embeddings to weaver input embeddings
+        self.weaver_to_reasoner = nn.Linear(weaver_hidden_size, reasoner_hidden_size)  # Map weaver hidden states to reasoner input embeddings
+        
+        # delimiters for detecting augmentation points
+        self.delimiters: list[str] = [",", ".", "\n"]  
+
+        self.state = None
+
+        # postprocess
+        self._postprocess_models()
+        logging.info("##### MemGen Initialization #####")
+        log_trainable_params(self)
+
+    def _postprocess_models(self):
+        # fix base model parameters
+        fix_model_parameters(self.reasoner)  
+
+        # Ensure tokenizer has a pad token
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
+            self.tokenizer.padding_side = "left"
+            logging.info(
+                f"Tokenizer has no pad token. Using EOS token ({self.tokenizer.eos_token}) as pad token."
+            )
+
+        # Normalize the tokenizer's chat template
+        self.tokenizer.chat_template = CONVERSATION_TEMPLATE
+    
+
+    @property
+    def device(self):
+        return self.reasoner.device
+    
+    def _forward(
+        self, 
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor,   
+        **kwargs
+    ) -> torch.Tensor:
+        # preprocess inputs
+        assert input_ids.shape == attention_mask.shape == labels.shape
+        
+        tokenizer = self.tokenizer
+        reasoner = self.reasoner
+        weaver = self.weaver
+        delimiters = self.delimiters
+        max_augment_num = self.config.max_inference_aug_num  # Limit the number of inference augmentation points to avoid excessive augmentation
+        device = self.device
+        embeds_dtype = reasoner.get_input_embeddings().weight.dtype
+        B, _ = input_ids.shape
+        hidden_size = self.config.hidden_size
+
+        # select augment idx
+        augmentation_indices = self._select_augment_points_after_delimiter(
+            input_ids, labels, delimiters, tokenizer, max_augment_num
+        )
+        
+        # origin inputs embeds
+        inputs_embeds = reasoner.get_input_embeddings()(input_ids)
+                
+        # Initialize the start index and empty tensors for accumulating processed segments
+        current_start_idx = 0
+        current_inputs_embeds = torch.empty((B, 0, hidden_size), device=device, dtype=embeds_dtype)
+        current_attention_mask = torch.empty((B, 0), device=device, dtype=attention_mask.dtype)
+        current_latents_mask = torch.empty((B, 0), device=device, dtype=torch.bool)
+
+        # Iterate over the selected augmentation points
+        for aug_point_idx in augmentation_indices:
+            # Slice the current segment of original embeddings and attention mask
+            segment_inputs_embeds = inputs_embeds[:, current_start_idx:aug_point_idx]
+            segment_attention_mask = attention_mask[:, current_start_idx:aug_point_idx]
+            segment_latents_mask = torch.zeros((B, segment_inputs_embeds.size(1)), device=device, dtype=torch.bool)
+
+            # Concatenate the current segment to the accumulated embeddings and masks
+            current_inputs_embeds = torch.cat([current_inputs_embeds, segment_inputs_embeds], dim=1)
+            current_attention_mask = torch.cat([current_attention_mask, segment_attention_mask], dim=1)
+            current_position_ids = self._generate_position_ids(current_attention_mask)
+            current_latents_mask = torch.cat([current_latents_mask, segment_latents_mask], dim=1)
+
+            # Map reasoner embeddings to weaver embeddings for augmentation
+            weaver_inputs_embeds = self.reasoner_to_weaver(current_inputs_embeds)
+
+            # Determine whether this point is the end of the prompt (prompt augmentation)
+            is_prompt_end_aug = (labels[:, aug_point_idx] != -100).all() and (labels[:, aug_point_idx-1] == -100).all().item()
+            
+            # Depending on type, use weaver to augment prompt or inference
+            if is_prompt_end_aug:
+                weaver_hidden_states, attn_mask, pos_ids = weaver.augment_prompt(
+                    weaver_inputs_embeds, current_attention_mask, current_position_ids
+                )
+            else:
+                weaver_hidden_states, attn_mask, pos_ids = weaver.augment_inference(
+                    weaver_inputs_embeds, current_attention_mask, current_position_ids
+                ) 
+
+            # Map weaver hidden states back to reasoner embeddings
+            latent_inputs_embeds = self.weaver_to_reasoner(weaver_hidden_states)
+
+            # Update accumulated embeddings and masks with the newly augmented segment
+            current_inputs_embeds = torch.cat([current_inputs_embeds, latent_inputs_embeds], dim=1)
+            current_attention_mask = torch.cat([current_attention_mask, attn_mask], dim=1)
+            current_start_idx = aug_point_idx
+            
+            # Update latent mask for the newly added latent embeddings
+            latent_mask = torch.ones((B, latent_inputs_embeds.size(1)), device=device, dtype=torch.bool)
+            current_latents_mask = torch.cat([current_latents_mask, latent_mask], dim=1)
+            
+        # Process the remaining segment after the last augmentation point
+        remaining_inputs_embeds = inputs_embeds[:, current_start_idx:]
+        remaining_attention_mask = attention_mask[:, current_start_idx:]
+        latent_mask = torch.zeros((B, remaining_attention_mask.size(1)), device=device, dtype=torch.bool)
+        
+        current_inputs_embeds = torch.cat([current_inputs_embeds, remaining_inputs_embeds], dim=1)
+        current_attention_mask = torch.cat([current_attention_mask, remaining_attention_mask], dim=1)
+        current_position_ids = self._generate_position_ids(current_attention_mask)
+        current_latents_mask = torch.cat([current_latents_mask, latent_mask], dim=1)
+
+        reasoner_outputs = reasoner(
+            inputs_embeds=current_inputs_embeds,
+            attention_mask=current_attention_mask,
+            position_ids=current_position_ids
+        )
+        logits = reasoner_outputs.logits
+        
+        # Identify valid positions in logits (positions that should contribute to loss)
+        shifted = torch.zeros_like(current_latents_mask)
+        shifted[:, :-1] = current_latents_mask[:, 1:]
+        valid_mask = ~shifted
+        
+        valid_logits = logits[valid_mask].view(logits.size(0), -1, logits.size(2))  
+        # assert shifted.sum() == current_latents_mask.sum()
+        # assert valid_logits.shape[:2] == input_ids.shape
+        return valid_logits
+    
+    def _instructional_forward(
+        self, 
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor,   
+        **kwargs
+    ) -> tuple[torch.FloatTensor, torch.LongTensor]:
+        """
+        Forward pass for single-turn instructional data (no multi-turn conversation required).
+
+        This method is used for instruction-following tasks (SFT), where the input
+        consists of a single instruction and the corresponding labels. It directly
+        delegates to the single-turn forward method `_forward`.
+
+        Args:
+            input_ids (torch.Tensor): Tensor of shape (batch_size, seq_len) containing input token IDs.
+            attention_mask (torch.Tensor): Tensor indicating padding positions.
+            labels (torch.Tensor): Tensor containing the target labels for supervised fine-tuning.
+            **kwargs: Additional keyword arguments passed to `_forward`.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: 
+                - logits: The output logits from the model for each input token.
+                - labels: The same as input labels, used for loss computation.
+        """
+        # raise RuntimeError()
+        logits = self._forward(input_ids, attention_mask, labels, **kwargs)
+        # For Instruction SFT, labels remain the same as input
+        return logits, labels
+
+    def _conversational_forward(
+        self, 
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor,   
+        **kwargs
+    ) -> tuple[torch.FloatTensor, torch.LongTensor]:
+        """
+        Forward pass for conversational (multi-turn) data.
+
+        Multi-turn forward is constructed by sequentially calling the single-turn forward
+        for each conversation turn. Latents inserted in turn i-1 are not visible to turn i.
+
+        Args:
+            input_ids (torch.Tensor): Input token IDs, shape (1, seq_len). Batch size must be 1.
+            attention_mask (torch.Tensor): Attention mask for input tokens.
+            labels (torch.Tensor): Target labels for supervised fine-tuning (-100 for ignore positions).
+            **kwargs: Additional arguments passed to `_forward`.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]:
+                - all_logits: Logits for the entire sequence, with zeros for unsupervised positions.
+                - all_labels: Labels for the entire sequence, with -100 for unsupervised positions.
+        """
+        assert input_ids.shape[0] == 1, "Conversational SFT currently only supports batch_size = 1"
+        seq_len = input_ids.shape[1]
+        vocab_size = self.config.vocab_size
+        device = input_ids.device
+
+        # Identify single-turn segments within the conversation based on labels
+        label_row = labels[0]
+        should_supervise = label_row != -100
+        if not should_supervise.any():
+            raise ValueError("At least one completion segment is required")
+
+        # Compute the start and end indices of valid supervised segments
+        valid_mask = should_supervise.int()
+        diff = torch.diff(torch.cat([torch.tensor([0], device=device), valid_mask]))
+        valid_starts = (diff == 1).nonzero(as_tuple=True)[0].tolist()  # Transition 0 -> 1
+        ends = (diff == -1).nonzero(as_tuple=True)[0].tolist()          # Transition 1 -> 0
+        if len(ends) < len(valid_starts):
+            ends.append(seq_len)  # 自动补充最后一个 token 的 (index + 1) 作为最后一个序列的末尾
+        assert len(valid_starts) == len(ends)
+        
+        # Build triplets (start of previous segment, start of supervised segment, end of supervised segment)
+        triplets = []
+        start = 0
+        for s, e in zip(valid_starts, ends):
+            triplets.append((start, s, e))
+            start = e
+        
+        # If there are more segments than allowed, randomly select self.max_prompt_aug_num segments
+        if len(triplets) <= self.config.max_prompt_aug_num:
+            select_turns = [1] * len(triplets)
+        else:
+            triplets_num = len(triplets)
+            selected_indices = set(random.sample(range(triplets_num), self.config.max_prompt_aug_num))
+            select_turns = [1 if i in selected_indices else 0 for i in range(triplets_num)]
+
+        # Initialize tensors to store logits and labels for the entire sequence
+        all_logits = torch.zeros(1, seq_len, vocab_size, device=device)
+        all_labels = torch.full((1, seq_len), -100, device=device)
+
+        # Loop over each conversation turn and perform single-turn forward if supervised
+        for triplet, should_supervise in zip(triplets, select_turns):
+            start, valid_start, end = triplet
+            if should_supervise:
+                cur_input_ids = input_ids[0, :end].unsqueeze(0)
+                cur_attention = attention_mask[0, :end].unsqueeze(0)
+                # cur_labels only used for _forward, does not represent the true supervision range
+                # cur_labels = labels[0, :end].clone().unsqueeze(0)
+                # cur_labels[0, :valid_start] = -100  # Mask tokens before supervision start
+                cur_labels = torch.full((1, end), -100, device=device)
+                cur_labels[0, valid_start:end] = labels[0, valid_start:end]
+
+                # Single-turn forward for the current conversation segment
+                logits = self._forward(cur_input_ids, cur_attention, cur_labels, **kwargs)
+                
+                # Update overall logits and labels with the results of this segment
+                all_logits[0, start:end, :] = logits[0, start:end, :]
+                all_labels[0, start:end] = labels[0, start:end]
+
+        # Return logits and labels:
+        # - supervised positions retain computed logits and original labels
+        # - unsupervised positions have logits = 0 and labels = -100
+        return all_logits, all_labels
+
+    def forward(
+        self, 
+        input_ids: torch.Tensor, 
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor,
+        **kwargs
+    ) -> MemGenOutputWithPast:  
+        tokenizer = self.tokenizer
+
+        # Ensure labels are provided, required for training the reasoning processor
+        assert labels is not None, "Reasoning Processor requires input labels for training"
+        
+        # Determine whether the input is single-turn (instruction) or multi-turn (conversation)
+        labels = self._postprocess_assistant_labels(input_ids, labels, tokenizer)
+       
+        # Use only the first data sample of each dataset to determine the model state
+        if self.state is None:  
+            self.state = MemGenModel.CONVERSATION_STATE if self._is_conversation(input_ids, tokenizer) else MemGenModel.INSTRUCTION_STATE
+
+        if self.state == MemGenModel.INSTRUCTION_STATE:
+            forward_func = self._instructional_forward
+        elif self.state == MemGenModel.CONVERSATION_STATE:
+            forward_func = self._conversational_forward
+        else:
+            raise RuntimeError(f"Unexpected model state: {self.state}")
+        
+        batch_size = 1  # Currently process one sequence per batch
+        iter_num = input_ids.size(0) // batch_size
+
+        # Forward pass per batch
+        logits, supervised_labels = [], []
+        for i in range(iter_num):
+            batch_input_ids = input_ids[i * batch_size: (i + 1) * batch_size]
+            batch_attention_mask = attention_mask[i * batch_size: (i + 1) * batch_size]
+            batch_labels = labels[i * batch_size: (i + 1) * batch_size]
+
+            # Call the appropriate forward function (instruction or conversation)
+            batch_logits, batch_supervised_labels = forward_func(
+                input_ids=batch_input_ids,
+                attention_mask=batch_attention_mask,
+                labels=batch_labels,
+                **kwargs
+            )
+            logits.append(batch_logits)
+            supervised_labels.append(batch_supervised_labels)
+        
+        # Concatenate results from all batches
+        all_logits = torch.concat(logits, dim=0)
+        all_labels = torch.concat(supervised_labels, dim=0)
+
+        # Compute causal language modeling loss (shifted by one)
+        shift_logits = all_logits[..., :-1, :].contiguous()
+        shift_labels = all_labels[..., 1:].contiguous()
+        # assert shift_logits.shape[:-1] == shift_labels.shape
+        loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+        loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+
+        # Return model outputs
+        outputs = MemGenOutputWithPast(loss=loss, logits=all_logits)
+        outputs.supervised_labels = all_labels  # Positions in input_ids that are supervised
+        return outputs
+
+    # @torch.no_grad()
+    # def generate(
+    #     self, 
+    #     input_ids: torch.Tensor, 
+    #     attention_mask: torch.Tensor,
+    #     generation_config: GenerationConfig = None, 
+    #     return_augmentation_mask: bool = False,
+    #     **kwargs
+    # ) -> Union[torch.LongTensor, tuple[torch.LongTensor, torch.LongTensor]]: 
+        
+    #     tokenizer = self.tokenizer
+    #     reasoner = self.reasoner
+    #     weaver = self.weaver
+    #     max_augment_num = self.config.max_inference_aug_num
+    #     invalid_token_id = -100
+
+    #     # preproecess inputs
+    #     input_ids = input_ids.to(self.device)
+    #     attention_mask = attention_mask.to(self.device)
+    #     max_new_tokens = generation_config.max_new_tokens
+    #     pad_token_id = tokenizer.pad_token_id
+    #     eos_token_id = tokenizer.eos_token_id
+    #     prompt_len = input_ids.size(1)
+
+    #     inputs_embeds = reasoner.get_input_embeddings()(input_ids)
+    #     B, _, hidden_size = inputs_embeds.shape
+    #     device = inputs_embeds.device
+        
+    #     # --- generation loop ---
+    #     current_inputs_embeds = inputs_embeds
+    #     current_attention_mask = attention_mask
+    #     current_position_ids = self._generate_position_ids(current_attention_mask)
+    #     current_input_ids = input_ids
+    #     current_cache: DynamicCache = None
+
+    #     # Generation Loop Initialization
+    #     sentence_augment_count = torch.zeros(B, dtype=torch.int, device=device)
+        
+    #     # NOTE - Whether to call the trigger and insert latent memory before generating the token at this position
+    #     # - augmentation_pos[b][i] == -100: For the b-th sequence, no augmentation was sampled before generating the i-th token
+    #     # - augmentation_pos[b][i] == 0: For the b-th sequence, augmentation was sampled before generating the i-th token, but the trigger decided NOT to insert latent memory
+    #     # - augmentation_pos[b][i] == 1: For the b-th sequence, augmentation was sampled before generating the i-th token, and the trigger decided to insert latent memory
+    #     augmentation_pos = torch.full((B, max_new_tokens), fill_value=invalid_token_id, device=device) 
+
+    #     generation_config = GenerationConfig(
+    #         do_sample=False,
+    #         pad_token_id=pad_token_id,
+    #         eos_token_id=eos_token_id,
+    #         use_cache=False,
+    #         max_new_tokens=max_new_tokens
+    #     )
+    #     # Perform generation for the remaining tokens using the reasoner
+    #     generated = reasoner.generate(
+    #         inputs_embeds=current_inputs_embeds,
+    #         attention_mask=current_attention_mask,
+    #         generation_config=generation_config
+    #     )
+    #     current_input_ids = torch.cat([current_input_ids, generated], dim=1)
+
+    #     # postprocess
+    #     new_generated_len = current_input_ids.size(1) - prompt_len
+    #     augmentation_pos = augmentation_pos[:, :new_generated_len]
+        
+    #     self._check_generate(
+    #         current_input_ids[:, prompt_len:],
+    #         augmentation_pos
+    #     )
+        
+    #     if return_augmentation_mask:
+    #         return (current_input_ids, augmentation_pos)
+    #     else:
+    #         return current_input_ids
+
+    @torch.no_grad()
+    def generate(
+        self, 
+        input_ids: torch.Tensor, 
+        attention_mask: torch.Tensor,
+        generation_config: GenerationConfig = None, 
+        return_augmentation_mask: bool = False,
+        **kwargs
+    ) -> Union[torch.LongTensor, tuple[torch.LongTensor, torch.LongTensor]]: 
+        
+        tokenizer = self.tokenizer
+        reasoner = self.reasoner
+        weaver = self.weaver
+        max_augment_num = self.config.max_inference_aug_num
+        invalid_token_id = -100
+
+        # preproecess inputs
+        input_ids = input_ids.to(self.device)
+        attention_mask = attention_mask.to(self.device)
+        max_new_tokens = generation_config.max_new_tokens
+        pad_token_id = tokenizer.pad_token_id
+        eos_token_id = tokenizer.eos_token_id
+        prompt_len = input_ids.size(1)
+
+        inputs_embeds = reasoner.get_input_embeddings()(input_ids)
+        B, _, hidden_size = inputs_embeds.shape
+        device = inputs_embeds.device
+        
+        # --- generation loop ---
+        current_inputs_embeds = inputs_embeds
+        current_attention_mask = attention_mask
+        current_position_ids = self._generate_position_ids(current_attention_mask)
+        current_input_ids = input_ids
+        current_cache: DynamicCache = None
+
+        # Generation Loop Initialization
+        sentence_augment_count = torch.zeros(B, dtype=torch.int, device=device)
+        
+        # NOTE - Whether to call the trigger and insert latent memory before generating the token at this position
+        # - augmentation_pos[b][i] == -100: For the b-th sequence, no augmentation was sampled before generating the i-th token
+        # - augmentation_pos[b][i] == 0: For the b-th sequence, augmentation was sampled before generating the i-th token, but the trigger decided NOT to insert latent memory
+        # - augmentation_pos[b][i] == 1: For the b-th sequence, augmentation was sampled before generating the i-th token, and the trigger decided to insert latent memory
+        augmentation_pos = torch.full((B, max_new_tokens), fill_value=invalid_token_id, device=device) 
+
+        for i in range(max_new_tokens):
+            
+            assert current_inputs_embeds.shape[:2] == current_attention_mask.shape == current_position_ids.shape
+            augment_decision = self._should_augment(
+                current_input_ids, 
+                sentence_augment_count=sentence_augment_count, 
+                do_sample=generation_config.trigger_do_sample,
+                temperature=generation_config.temperature,
+                is_prompt=(i==0)  
+            )
+            augmentation_pos[:, i] = augment_decision
+            augment_indices = torch.where(augment_decision == 1)[0]
+
+            # If there are sentences to augment, apply augmentation; others remain with left padding
+            if len(augment_indices) > 0:
+                # Increment the augmentation count for sentences that are being augmented
+                if i != 0:  
+                    sentence_augment_count[augment_indices] += 1
+
+                # Select embeddings, attention masks, and position IDs for sentences to be augmented
+                candidate_inputs_embeds = current_inputs_embeds[augment_indices]
+                candidate_attention_mask = current_attention_mask[augment_indices]
+                candidate_position_ids = current_position_ids[augment_indices]
+                
+                # Perform inference augmentation using the weaver
+                weaver_inputs_embeds = self.reasoner_to_weaver(candidate_inputs_embeds)
+                if i == 0:
+                    weaver_hidden_states, attn_mask, _ = weaver.augment_prompt(
+                        weaver_inputs_embeds, candidate_attention_mask, candidate_position_ids
+                    )                    
+                else:
+                    weaver_hidden_states, attn_mask, _ = weaver.augment_inference(
+                        weaver_inputs_embeds, candidate_attention_mask, candidate_position_ids
+                    )
+                latent_inputs_embeds = self.weaver_to_reasoner(weaver_hidden_states)
+                
+                candidate_inputs_embeds = torch.cat([candidate_inputs_embeds, latent_inputs_embeds], dim=1)
+                candidate_attention_mask = torch.cat([candidate_attention_mask, attn_mask], dim=1)
+                
+                # Create a single merged tensor for all sequences
+                new_len = candidate_inputs_embeds.size(1)
+                merged_inputs_embeds = torch.zeros((B, new_len, hidden_size), device=device, dtype=current_inputs_embeds.dtype)
+                merged_attention_mask = torch.zeros((B, new_len), device=device, dtype=current_attention_mask.dtype)
+                   
+                # Directly place augmented and non-augmented sequences
+                merged_inputs_embeds[augment_indices] = candidate_inputs_embeds
+                merged_attention_mask[augment_indices] = candidate_attention_mask
+                
+                # Non-augmented sequences now include both -100 and 0
+                non_augment_indices = torch.where(augment_decision != 1)[0]
+                if len(non_augment_indices) > 0:
+                    # dynamic left padding
+                    non_aug_inputs_embeds = current_inputs_embeds[non_augment_indices]
+                    non_aug_attention_mask = current_attention_mask[non_augment_indices]
+                    pad_len = weaver.prompt_latents_num if i == 0 else weaver.inference_latents_num
+                    non_aug_inputs_embeds, non_aug_attention_mask, _ = self._left_pad(
+                        non_aug_inputs_embeds, non_aug_attention_mask, None, pad_len
+                    )
+                    
+                    merged_inputs_embeds[non_augment_indices] = non_aug_inputs_embeds
+                    merged_attention_mask[non_augment_indices] = non_aug_attention_mask
+                
+                current_inputs_embeds = merged_inputs_embeds
+                current_attention_mask = merged_attention_mask
+                current_position_ids = self._generate_position_ids(current_attention_mask)
+                current_cache = None  
+
+            # Check if all sequences have reached the maximum number of augmentations
+            if (sentence_augment_count >= max_augment_num).all():
+                # Adjust the remaining generation length
+                generation_config_continue = GenerationConfig(
+                    do_sample=generation_config.weaver_do_sample,
+                    pad_token_id=pad_token_id,
+                    eos_token_id=eos_token_id,
+                    use_cache=False,
+                    max_new_tokens=max_new_tokens-i
+                )
+                # Perform generation for the remaining tokens using the reasoner
+                generated = reasoner.generate(
+                    inputs_embeds=current_inputs_embeds,
+                    attention_mask=current_attention_mask,
+                    generation_config=generation_config_continue
+                )
+                current_input_ids = torch.cat([current_input_ids, generated], dim=1)
+                break            
+
+            if current_cache is not None:
+                assert current_inputs_embeds.size(1) == current_cache.get_seq_length() + 1
+                reasoner_inputs_embeds = current_inputs_embeds[:, -1:]
+                reasoner_position_ids = current_position_ids[:, -1:]
+            else:
+                reasoner_inputs_embeds = current_inputs_embeds
+                reasoner_position_ids = current_position_ids
+
+            outputs = reasoner(
+                inputs_embeds=reasoner_inputs_embeds,
+                attention_mask=current_attention_mask,
+                position_ids=reasoner_position_ids,
+                output_hidden_states=False,
+                use_cache=True,
+                past_key_values=current_cache
+            )
+            current_inputs_embeds, current_attention_mask, current_position_ids, current_input_ids = self._append_one_step(
+                outputs, 
+                current_inputs_embeds, 
+                current_attention_mask, 
+                current_position_ids, 
+                current_input_ids, 
+                do_sample=generation_config.weaver_do_sample, 
+                temperature=generation_config.temperature
+            )
+            current_cache = outputs.past_key_values
+
+            # If all sequences in the batch have already generated an EOS token, stop early
+            if (current_input_ids[:, -1] == eos_token_id).all():
+                break  
+
+            # This is needed to properly delete outputs.logits which may be very large for first iteration
+            # Otherwise a reference to outputs is kept which keeps the logits alive in the next iteration
+            del outputs
+        
+        # postprocess
+        new_generated_len = current_input_ids.size(1) - prompt_len
+        augmentation_pos = augmentation_pos[:, :new_generated_len]
+        
+        self._check_generate(
+            current_input_ids[:, prompt_len:],
+            augmentation_pos
+        )
+        
+        if return_augmentation_mask:
+            return (current_input_ids, augmentation_pos)
+        else:
+            return current_input_ids
+    
+    @classmethod
+    def from_config(cls, config_dict: dict):
+        # base LLM
+        model_name = config_dict.get("model_name")
+
+        # max augment numbers
+        max_prompt_aug_num = config_dict.get("max_prompt_aug_num", 1)
+        max_inference_aug_num = config_dict.get("max_inference_aug_num", 5)
+
+        # weaver configs
+        weaver_config = config_dict.get("weaver", {})
+        prompt_latents_len = weaver_config.get("prompt_latents_len", 8)
+        inference_latents_len = weaver_config.get("inference_latents_len", 8)
+        weaver_lora_config_dict = weaver_config.get("lora_config", None)
+        weaver_model_name = weaver_config.get("model_name", None)
+
+        # trigger configs
+        trigger_config = config_dict.get("trigger", {})
+        trigger_active = trigger_config.get("active", False)
+        trigger_lora_config_dict = trigger_config.get("lora_config", None)
+        trigger_model_name = trigger_config.get("model_name", None)
+
+        # build MemGenConfig
+        from transformers import AutoConfig
+        memgen_config = AutoConfig.from_pretrained(model_name)
+        memgen_config = MemGenConfig.from_pretrained(
+            model_name, 
+            max_prompt_aug_num=max_prompt_aug_num,
+            max_inference_aug_num=max_inference_aug_num,
+            prompt_latents_len=prompt_latents_len,
+            inference_latents_len=inference_latents_len,
+            weaver_lora_config=weaver_lora_config_dict,
+            trigger_active=trigger_active,
+            trigger_lora_config=trigger_lora_config_dict
+        )
+        
+        # load pretrained base models
+        base_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        reasoner_base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2")
+        weaver_base_model = AutoModelForCausalLM.from_pretrained(weaver_model_name, torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2")
+        trigger_base_model = AutoModelForCausalLM.from_pretrained(trigger_model_name, torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2")
+        
+        # instantiate MemGen Model
+        load_model_path = config_dict.get("load_model_path", None)
+        
+        if not load_model_path:
+            model = cls(
+                config=memgen_config, 
+                base_tokenizer=base_tokenizer,
+                reasoner_base_model=reasoner_base_model, 
+                weaver_base_model=weaver_base_model,
+                trigger_base_model=trigger_base_model
+            )
+        else:
+            model = cls.from_pretrained(
+                load_model_path, 
+                config=memgen_config,
+                base_tokenizer=base_tokenizer,
+                reasoner_base_model=reasoner_base_model,
+                weaver_base_model=weaver_base_model,
+                trigger_base_model=trigger_base_model
+            )
+        
+        return model
+
+    def save_pretrained(self, save_directory: str, **kwargs):
+        os.makedirs(save_directory, exist_ok=True)
+
+        self.config.save_pretrained(save_directory)
+
+        torch.save(
+            {
+                "reasoner_to_weaver": self.reasoner_to_weaver.state_dict(),
+                "weaver_to_reasoner": self.weaver_to_reasoner.state_dict(),
+            },
+            os.path.join(save_directory, "projs.bin"),
+        )
+
+        torch.save(
+            {
+                "prompt_query_latents": self.weaver.prompt_query_latents.data,
+                "inference_query_latents": self.weaver.inference_query_latents.data,
+                "prompt_latent_ln": self.weaver.prompt_latent_ln.state_dict(),
+                "inference_latent_ln": self.weaver.inference_latent_ln.state_dict(),
+                "prompt_latent_scale": self.weaver.prompt_latent_scale.data,
+                "inference_latent_scale": self.weaver.inference_latent_scale.data,
+            },
+            os.path.join(save_directory, "weaver.bin"),
+        )
+
+        torch.save(
+            {
+                "output_layer": self.trigger.output_layer.state_dict(),
+            },
+            os.path.join(save_directory, "trigger.bin"),
+        )
+
+        self.weaver.model.save_pretrained(os.path.join(save_directory, "weaver"))
+        self.trigger.model.save_pretrained(os.path.join(save_directory, "trigger"))
+
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        load_directory: str,
+        *,
+        config,
+        base_tokenizer,
+        reasoner_base_model,
+        weaver_base_model,
+        trigger_base_model,
+    ):
+        model = cls(
+            config=config,
+            base_tokenizer=base_tokenizer,
+            reasoner_base_model=reasoner_base_model,
+            weaver_base_model=weaver_base_model,
+            trigger_base_model=trigger_base_model,
+        )
+
+        proj_path = os.path.join(load_directory, "projs.bin")
+        proj_state = torch.load(proj_path, map_location="cpu")
+        model.reasoner_to_weaver.load_state_dict(proj_state["reasoner_to_weaver"])
+        model.weaver_to_reasoner.load_state_dict(proj_state["weaver_to_reasoner"])
+
+        weaver_path = os.path.join(load_directory, "weaver.bin")
+        weaver_state = torch.load(weaver_path, map_location="cpu")
+        model.weaver.prompt_query_latents.data.copy_(weaver_state["prompt_query_latents"])
+        model.weaver.inference_query_latents.data.copy_(weaver_state["inference_query_latents"])
+        model.weaver.prompt_latent_ln.load_state_dict(weaver_state["prompt_latent_ln"])
+        model.weaver.inference_latent_ln.load_state_dict(weaver_state["inference_latent_ln"])
+        model.weaver.prompt_latent_scale.data.copy_(weaver_state["prompt_latent_scale"])
+        model.weaver.inference_latent_scale.data.copy_(weaver_state["inference_latent_scale"])
+
+        trigger_path = os.path.join(load_directory, "trigger.bin")
+        trigger_state = torch.load(trigger_path, map_location="cpu")
+        model.trigger.output_layer.load_state_dict(trigger_state["output_layer"])
+
+        model.weaver.model = PeftModel.from_pretrained(
+            model.weaver.model.base_model,
+            os.path.join(load_directory, "weaver", "weaver"),
+            adapter_name=MemGenWeaver.adapter_name,
+        )
+        model.weaver.model.set_adapter(MemGenWeaver.adapter_name)
+
+        model.trigger.model = PeftModel.from_pretrained(
+            model.trigger.model.base_model,
+            os.path.join(load_directory, "trigger", "trigger"),
+            adapter_name=MemGenTrigger.adapter_name,
+        )
+        model.trigger.model.set_adapter(MemGenTrigger.adapter_name)
+
+        logging.info("##### MemGen from Pretrained #####")
+        log_trainable_params(model)
+
+        return model
+

MemGen-main/memgen/model/modeling_utils.py

@@ -0,0 +1,430 @@
+from dataclasses import dataclass
+import logging
+import os
+from typing import Optional, Literal, Set
+
+from peft import PeftModel, LoraConfig
+import torch
+import torch.nn.functional as F
+from transformers import PreTrainedTokenizerBase
+from transformers.generation.utils import GenerationMixin
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.modeling_utils import PreTrainedModel
+
+from memgen.model.trigger import MemGenTrigger
+from memgen.model.weaver import MemGenWeaver
+from memgen.utils import (
+    CONVERSATION_TEMPLATE,
+    fix_model_parameters,
+    open_model_parameters
+)
+
+@dataclass
+class MemGenOutputWithPast(CausalLMOutputWithPast):
+    supervised_labels: Optional[torch.LongTensor] = None
+
+class MemGenLoraSwitchMixin:
+
+    def _insert_lora_adapters(
+        self, 
+        weaver_model: PreTrainedModel, 
+        weaver_lora_config: dict, 
+        trigger_model: PreTrainedModel, 
+        trigger_lora_config: dict
+    ) -> tuple[PeftModel, PeftModel]:
+        # insert lora adapters into weaver and trigger
+        weaver_lora_config = LoraConfig(**weaver_lora_config)
+        trigger_lora_config = LoraConfig(**trigger_lora_config)
+    
+        weaver_model_with_lora = PeftModel(
+            weaver_model, weaver_lora_config, adapter_name=MemGenWeaver.adapter_name
+        )
+        trigger_model_with_lora = PeftModel(
+            trigger_model, trigger_lora_config, adapter_name=MemGenTrigger.adapter_name
+        )
+
+        return weaver_model_with_lora, trigger_model_with_lora
+    
+    def fix_component(self, name: Literal["weaver", "trigger"]):
+        # frozen parameters of weaver or trigger
+        component = getattr(self, name)
+        fix_model_parameters(component)
+        if name == "weaver":
+            fix_model_parameters(self.weaver_to_reasoner)
+            fix_model_parameters(self.reasoner_to_weaver)
+    
+    def open_component(self, name: Literal["weaver", "trigger"]):
+        # open parameters of weaver or trigger
+        component = getattr(self, name)  
+        open_model_parameters(component)
+        if name == "weaver":
+            open_model_parameters(self.weaver_to_reasoner)
+            open_model_parameters(self.reasoner_to_weaver)        
+        
+        fix_model_parameters(component.model.base_model) # only finetune the lora adapters of the specific component
+        
+        for n, p in component.model.named_parameters():
+            if "lora_A" in n or "lora_B" in n:
+                if name in n:
+                    assert p.requires_grad, f"{n} should be trainable"
+                else:
+                    assert not p.requires_grad, f"{n} should be frozen"
+
+
+class MemGenGenerationMixin(GenerationMixin):
+
+    def _get_next_token(
+        self, 
+        next_token_logits: torch.Tensor, 
+        do_sample: bool, 
+        temperature: Optional[float] = 0.0
+    ) -> torch.Tensor:
+        if len(next_token_logits.shape) != 2:
+            raise ValueError("Input logits must be a 2D tensor [batch_size, vocab_size]")
+        
+        if do_sample and temperature != 0:  # Apply temperature scaling and sample from the resulting probability distribution    
+            probs = F.softmax(next_token_logits / temperature, dim=-1)
+            return torch.multinomial(probs, num_samples=1)
+        else:  # Greedy decoding: pick the token with the highest probability
+            return torch.argmax(next_token_logits, dim=-1, keepdim=True)
+
+    def _generate_position_ids(self, attention_mask: torch.Tensor) -> torch.Tensor:
+        position_ids = (attention_mask.cumsum(-1) - 1).clamp(min=0)
+        position_ids.masked_fill_(attention_mask == 0, 0)
+        return position_ids
+
+    def _is_conversation(self, input_ids: torch.Tensor, tokenizer) -> bool:
+        # if the input_ids has more than one <|im_start|>assistant\n, then it will be considered as a conversation
+        if len(input_ids.shape) != 2:
+            raise ValueError("input_ids must be a 2D tensor of shape (batch_size, seq_len)")
+        
+        seq = input_ids[0].tolist()
+
+        im_start_ids = tokenizer.encode("<|im_start|>", add_special_tokens=False)
+        assistant_ids = tokenizer.encode("assistant", add_special_tokens=False)
+
+        target_seq = im_start_ids + assistant_ids
+
+        count = 0
+        for i in range(len(seq) - len(target_seq) + 1):
+            if seq[i:i+len(target_seq)] == target_seq:
+                count += 1
+
+        return count > 1
+
+
+    def _postprocess_assistant_labels(
+        self,
+        input_ids: torch.Tensor,
+        labels: torch.Tensor,
+        tokenizer
+    ) -> torch.Tensor:
+        if tokenizer.chat_template != CONVERSATION_TEMPLATE:
+            raise ValueError(
+                "Invalid tokenizer.chat_template detected.\n"
+                f"Expected:\n{CONVERSATION_TEMPLATE}\n\n"
+                f"Got:\n{tokenizer.chat_template}\n\n"
+                "Please ensure that you are using the correct conversation template."
+            )
+        
+        # Encode the token sequence for "<|im_start|>assistant\n"
+        pattern_ids: list[int] = tokenizer.encode("<|im_start|>assistant\n", add_special_tokens=False)
+
+        batch_size, seq_len = input_ids.shape
+        new_labels = labels.clone()
+
+        for b in range(batch_size):
+            seq = input_ids[b].tolist()
+            for i in range(len(seq) - len(pattern_ids) + 1):
+                # Mask positions matching the pattern
+                if seq[i : i + len(pattern_ids)] == pattern_ids:
+                    new_labels[b, i : i + len(pattern_ids)] = -100
+
+        return new_labels
+
+    def _get_delimiter_token_ids(self, tokenizer, delimiters: list[str]) -> Set[int]:
+        """预计算 delimiter 对应的 token ids (在 __init__ 后调用一次)"""
+        delimiter_token_ids = set()
+        for d in delimiters:
+            ids = tokenizer.encode(d, add_special_tokens=False)
+            delimiter_token_ids.update(ids)
+        return delimiter_token_ids
+
+    def _check_ends_with_delimiter(
+        self, input_ids: torch.Tensor, tokenizer, delimiters: list[str]
+    ) -> torch.Tensor:
+        """检查每个序列的最后一个 token 是否是 delimiter token (O(1) 每序列，无 decode)"""
+        batch_size = input_ids.size(0)
+        device = input_ids.device
+
+        # 获取最后一个有效 token (跳过 padding)
+        pad_token_id = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else 0
+        mask = input_ids != pad_token_id
+        last_positions = mask.sum(dim=1).clamp(min=1) - 1
+        last_tokens = input_ids[torch.arange(batch_size, device=device), last_positions]
+
+        # 预计算并缓存 delimiter token ids tensor (只执行一次)
+        cache_key = '_delimiter_token_tensor'
+        if not hasattr(self, cache_key):
+            token_ids = self._get_delimiter_token_ids(tokenizer, delimiters)
+            setattr(self, cache_key, torch.tensor(list(token_ids), device=device))
+
+        delimiter_tensor = getattr(self, cache_key)
+        is_delimiter = (last_tokens.unsqueeze(1) == delimiter_tensor).any(dim=1)
+
+        return is_delimiter.unsqueeze(1)
+    
+    def _select_augment_points_after_delimiter(
+        self,
+        input_ids: torch.Tensor,
+        labels: torch.Tensor,
+        delimiters: list[str],
+        tokenizer: PreTrainedTokenizerBase,
+        max_num: int = 10,
+    ) -> list[int]:
+
+        assert input_ids.shape == labels.shape
+        B, seq_len = input_ids.size(0), input_ids.size(1)
+
+        prompt_augment_idx = []
+        inference_augment_idx = []
+
+        for i in range(1, seq_len):  # Skip the first token and last token for augmentation
+            # Detect the boundary between prompt and label for prompt augmentation
+            if (labels[:, i] != -100).all() and (labels[:, i - 1] == -100).all():
+                prompt_augment_idx.append(i)
+
+            # Detect valid label regions for inference augmentation
+            elif (labels[:, i] != -100).all() and (labels[:, i - 1] != -100).all():
+                batch_tokens_before_i = input_ids[:, :i]
+                # Fast token-level check (no decode)
+                if self._check_ends_with_delimiter(batch_tokens_before_i, tokenizer, delimiters).any():
+                    inference_augment_idx.append(i)
+        
+        # Ensure exactly one prompt augmentation point exists for single-turn processing
+        if len(prompt_augment_idx) != 1:
+            logging.error("❌ Unexpected number of prompt augment indices: %s", prompt_augment_idx)
+            logging.error("The inference_augment_idx: %s", inference_augment_idx)
+            logging.error("Batch size = %d, seq_len = %d", B, seq_len)
+
+            for b in range(B):
+                ids = input_ids[b].tolist()
+                labs = labels[b].tolist()
+                toks = tokenizer.convert_ids_to_tokens(ids)
+
+                logging.error("---- Sample %d ----", b)
+                logging.error("Decoded text:\n%s", tokenizer.decode(ids, skip_special_tokens=False))
+
+                vis = []
+                for t, l in zip(toks, labs):
+                    tag = "MASK" if l == -100 else "LAB"
+                    vis.append(f"{t}<{tag}>")
+
+                logging.error("Token-level view:\n%s", " ".join(vis))
+
+                boundaries = []
+                for i in range(1, seq_len):
+                    if labs[i] != -100 and labs[i - 1] == -100:
+                        boundaries.append(i)
+                logging.error("Detected prompt→label boundaries at positions: %s", boundaries)
+            raise ValueError("Single-turn forward must have exactly one prompt augment index")
+
+        final_points = prompt_augment_idx[:1]
+
+        # Limit the number of inference augmentation points to max_num
+        if len(inference_augment_idx) > max_num: 
+            inference_augment_idx = inference_augment_idx[:max_num]
+
+        final_points.extend(inference_augment_idx)
+        
+        if len(final_points) == 0:
+            raise RuntimeError("No valid augmentation points found")
+        
+        final_points.sort()
+        return final_points
+
+    @torch.no_grad()
+    def _should_augment(
+        self, 
+        input_ids: torch.LongTensor, 
+        sentence_augment_count: torch.LongTensor, 
+        do_sample: bool,
+        temperature: float,
+        is_prompt: bool = False
+    ) -> torch.LongTensor:
+            
+        tokenizer = self.tokenizer
+        delimiters = self.delimiters
+        trigger = self.trigger
+        max_augment_num = self.config.max_inference_aug_num
+
+        batch_size = input_ids.size(0)
+        
+        if is_prompt:  
+            attention_mask = (input_ids != tokenizer.pad_token_id).long()
+            position_ids = self._generate_position_ids(attention_mask)
+            aug_vector = torch.zeros((batch_size,), dtype=torch.long, device=input_ids.device)
+            trigger_indices = (aug_vector != -100).nonzero(as_tuple=True)[0]
+
+        else:  
+            attention_mask = (input_ids != tokenizer.pad_token_id).long()
+            position_ids = self._generate_position_ids(attention_mask)
+            aug_vector = torch.full((batch_size,), -100, dtype=torch.long, device=input_ids.device)
+            ends_with_delimiters = self._check_ends_with_delimiter(input_ids, tokenizer, delimiters).squeeze(1)
+            aug_vector[ends_with_delimiters] = 0
+            over_limit = (sentence_augment_count >= max_augment_num)
+            aug_vector[over_limit] = -100
+            trigger_indices = (aug_vector != -100).nonzero(as_tuple=True)[0]
+
+        if trigger_indices.numel() > 0:
+            trigger_logits = trigger(
+                input_ids=input_ids[trigger_indices],
+                attention_mask=attention_mask[trigger_indices],
+                position_ids=position_ids[trigger_indices]
+            )
+            last_token_logits = trigger_logits[:, -1]  # [batch, 2]
+
+            next_tokens = self._get_next_token(
+                last_token_logits,
+                do_sample=do_sample,
+                temperature=temperature
+            ).view(-1)
+
+            aug_vector[trigger_indices] = next_tokens
+
+        return aug_vector
+
+
+    @torch.no_grad()
+    def _append_one_step(
+        self,
+        reasoner_outputs, 
+        current_inputs_embeds: torch.Tensor,
+        current_attention_mask: torch.Tensor,
+        current_position_ids: torch.Tensor,
+        current_input_ids: torch.Tensor,
+        do_sample: bool,
+        temperature: float
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        B = current_inputs_embeds.size(0)
+        
+        # Append next token
+        next_token_logits = reasoner_outputs.logits[:, -1]
+        next_token_ids = self._get_next_token(next_token_logits, do_sample=do_sample, temperature=temperature)
+        current_input_ids = torch.cat([current_input_ids, next_token_ids], dim=1)
+        
+        # Append next token embeds
+        next_token_embeds = self.reasoner.get_input_embeddings()(next_token_ids)
+        current_inputs_embeds = torch.cat([current_inputs_embeds, next_token_embeds], dim=1)
+        
+        # Append attention mask
+        attn_mask = torch.ones((B, 1), dtype=current_attention_mask.dtype, device=current_attention_mask.device)
+        current_attention_mask = torch.cat([current_attention_mask, attn_mask], dim=1)
+        
+        # Append position ids
+        next_position_id = current_position_ids[:, -1:] + 1
+        current_position_ids = torch.cat([current_position_ids, next_position_id], dim=1)
+
+        return current_inputs_embeds, current_attention_mask, current_position_ids, current_input_ids
+    
+
+    @torch.no_grad()
+    def _left_pad(
+        self,
+        input_embeds: torch.FloatTensor,
+        attention_mask: torch.LongTensor,
+        position_ids: torch.LongTensor,
+        pad_num: int
+    ) -> tuple[torch.FloatTensor, torch.LongTensor, torch.LongTensor]:
+        
+        if input_embeds is not None:
+            B, L, D = input_embeds.shape
+            pad_embeds = torch.zeros((B, pad_num, D), dtype=input_embeds.dtype, device=input_embeds.device)
+            input_embeds = torch.cat([pad_embeds, input_embeds], dim=1)  # [B, pad_num + L, D]
+        
+        if attention_mask is not None:
+            B = attention_mask.size(0)
+            pad_mask = torch.zeros((B, pad_num), dtype=attention_mask.dtype, device=attention_mask.device)
+            attention_mask = torch.cat([pad_mask, attention_mask], dim=1)  # [B, pad_num + L]
+        
+        if position_ids is not None:
+            B = position_ids.size(0)
+            pad_pos = torch.zeros((B, pad_num), dtype=position_ids.dtype, device=position_ids.device)
+            position_ids = torch.cat([pad_pos, position_ids], dim=1)  # [B, pad_num + L]
+
+        return input_embeds, attention_mask, position_ids
+    
+    @torch.no_grad()
+    def _left_clip_pad_tokens(
+        self, inputs_embeds: torch.FloatTensor, attention_mask: torch.LongTensor, position_ids: torch.LongTensor
+    ) -> tuple[torch.FloatTensor, torch.LongTensor, torch.LongTensor]:
+
+        B, L, D = inputs_embeds.shape
+
+        # Find the index of the first non-padding token in each sequence
+        first_nonpad_idx = []
+        for b in range(B):
+            nonzero = (attention_mask[b] != 0).nonzero(as_tuple=True)[0]
+            if len(nonzero) == 0:
+                # Entire row is padding; can potentially trim the whole sequence
+                first_nonpad_idx.append(L)
+            else:
+                first_nonpad_idx.append(nonzero[0].item())
+        
+        # Determine the minimum number of left-padding tokens across the batch
+        min_pad = min(first_nonpad_idx)
+
+        # If no padding on the left, return original tensors
+        if min_pad == 0:
+            return inputs_embeds, attention_mask, position_ids
+
+        # Trim the left-padding from all sequences in the batch
+        inputs_embeds = inputs_embeds[:, min_pad:, :]
+        attention_mask = attention_mask[:, min_pad:]
+        position_ids = position_ids[:, min_pad:]
+
+        return inputs_embeds, attention_mask, position_ids
+    
+    @torch.no_grad()
+    def _check_generate(self, input_ids: torch.LongTensor, augmentation_pos: torch.LongTensor):
+        """检查 augmentation_pos[b][i] == 1 的位置, input_ids[b][:i] (不包括第 i 位) 对应的字符串是否以 delimiters 结尾
+        仅在 DEBUG_MODE 下启用，避免训练时的性能开销
+        """
+        # 仅在 DEBUG 模式下执行验证，避免训练时的大量 decode 开销
+        if os.environ.get('DEBUG_MODE', '').lower() != 'true':
+            return
+
+        delimiters = self.delimiters
+        tokenizer = self.tokenizer
+
+        B, L = input_ids.shape
+        assert augmentation_pos.shape == input_ids.shape
+
+        for b in range(B):
+            for i in range(1, L):
+                is_augment_point = augmentation_pos[b, i].item()
+
+                if is_augment_point == -100:
+                    continue
+
+                if is_augment_point == 1 or is_augment_point == 0:
+                    prefix_input_ids = input_ids[b, :i].unsqueeze(0)
+
+                    ends_with_delimiter = self._check_ends_with_delimiter(
+                        prefix_input_ids, tokenizer, delimiters
+                    ).item()
+
+                    if not ends_with_delimiter:
+                        decoded_prefix = tokenizer.decode(prefix_input_ids.squeeze(0), skip_special_tokens=False)
+
+                        raise ValueError(
+                            f"Augmentation position error at batch {b}, index {i}. "
+                            f"augmentation_pos is 1, but the prefix does NOT end with a delimiter.\n"
+                            f"Prefix: '...{decoded_prefix[-50:]}'\n"
+                            f"Delimiters: {delimiters}"
+                        )
+                else:
+                    raise ValueError(
+                        f"Invalid value in augmentation_pos at batch {b}, index {i}: {is_augment_point}. "
+                        "Expected 1, 0, or -100."
+                    )

MemGen-main/memgen/model/trigger.py

@@ -0,0 +1,45 @@
+from peft import PeftModel
+import torch
+import torch.nn as nn
+
+
+class MemGenTrigger(nn.Module):
+    adapter_name = "trigger"
+
+    def __init__(
+        self,
+        model: PeftModel,
+        active: bool,
+    ):
+        super().__init__()
+        
+        self.active = active
+        self.model = model
+        self.output_layer = nn.Linear(model.base_model.config.hidden_size, 2)
+
+    def forward(
+        self, 
+        input_ids: torch.LongTensor, 
+        attention_mask: torch.LongTensor,
+        position_ids: torch.Tensor
+    ) -> torch.FloatTensor:
+        
+        if self.active:
+            outputs = self.model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                position_ids=position_ids,  
+                output_hidden_states=True,
+            )
+            hidden_states = outputs.hidden_states[-1]
+            logits = self.output_layer(hidden_states)
+        
+        else:
+            batch_size, seq_len = input_ids.shape
+            logits = torch.zeros(batch_size, seq_len, 2, device=input_ids.device)  # logits: [batch_size, seq_len, 2]
+            logits[..., 1] = 1.0  
+
+        return logits
+
+
+

MemGen-main/memgen/model/weaver.py

@@ -0,0 +1,125 @@
+from peft import PeftModel
+import torch
+import torch.nn as nn
+
+
+class MemGenWeaver(nn.Module):
+
+    adapter_name = "weaver"
+
+    def __init__(
+        self, 
+        model: PeftModel,
+        prompt_latents_len: int,
+        inference_latents_len: int,
+    ):
+        super().__init__()
+
+        self.model = model
+        hidden_size = model.base_model.config.hidden_size
+
+        # prompt augmentation
+        self.prompt_query_latents = nn.Parameter(
+            torch.randn(prompt_latents_len, hidden_size), 
+            requires_grad=True
+        )
+
+        # inference augmentation
+        self.inference_query_latents = nn.Parameter(
+            torch.randn(inference_latents_len, hidden_size), 
+            requires_grad=True
+        )
+
+        # latent normalization + scale
+        self.prompt_latent_ln = nn.LayerNorm(hidden_size)
+        self.inference_latent_ln = nn.LayerNorm(hidden_size)
+        self.prompt_latent_scale = nn.Parameter(torch.ones(1))
+        self.inference_latent_scale = nn.Parameter(torch.ones(1))
+
+    @property
+    def prompt_latents_num(self) -> int:
+        return self.prompt_query_latents.size(0)
+
+    @property
+    def inference_latents_num(self) -> int:
+        return self.inference_query_latents.size(0)
+
+    @property
+    def device(self):
+        assert self.prompt_query_latents.device == self.inference_query_latents.device
+        return self.prompt_query_latents.device
+
+    def _augment(
+        self, 
+        latents: torch.Tensor,
+        latent_ln: nn.LayerNorm,
+        latent_scale: torch.Tensor,
+        inputs_embeds: torch.Tensor, 
+        attention_mask: torch.Tensor, 
+        position_ids: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+
+        batch_size = attention_mask.shape[0]
+        latents_num = latents.size(0)
+
+        # normalize + scale
+        latents = latent_ln(latents) * latent_scale
+        latents = latents.unsqueeze(0).repeat(batch_size, 1, 1)
+        
+        # inputs_embeds
+        inputs_embeds = torch.cat([inputs_embeds, latents], dim=1)
+
+        # attention_mask: (B, L_total)
+        latents_mask = torch.ones(latents.shape[:-1], dtype=attention_mask.dtype, device=attention_mask.device)
+        attention_mask = torch.cat([attention_mask, latents_mask], dim=1)
+        
+        # get position ids
+        last_position_ids = position_ids.max(dim=1)[0]
+        latents_relative_positions = torch.arange(latents_num, device=attention_mask.device)
+        latents_position_ids = last_position_ids.unsqueeze(1) + latents_relative_positions + 1
+        position_ids = torch.cat([position_ids.long(), latents_position_ids.long()], dim=1) 
+
+        # the processor only outputs the hidden states
+        assert inputs_embeds.shape[:2] == attention_mask.shape == position_ids.shape
+
+        outputs = self.model(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids,  
+            output_hidden_states=True,
+        )
+        hidden_states = outputs.hidden_states[-1]
+        latents_hidden_states = hidden_states[:, -latents_num:, :]
+
+        return latents_hidden_states, latents_mask, latents_position_ids
+
+    def augment_prompt(
+        self, 
+        inputs_embeds: torch.Tensor, 
+        attention_mask: torch.Tensor, 
+        position_ids: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self._augment(
+            latents=self.prompt_query_latents,
+            latent_ln=self.prompt_latent_ln,
+            latent_scale=self.prompt_latent_scale,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids
+        )
+
+
+    def augment_inference(
+        self, 
+        inputs_embeds: torch.Tensor, 
+        attention_mask: torch.Tensor, 
+        position_ids: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self._augment(
+            latents=self.inference_query_latents,
+            latent_ln=self.inference_latent_ln,
+            latent_scale=self.inference_latent_scale,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids
+        )

MemGen-main/memgen/runner.py

@@ -0,0 +1,446 @@
+import os
+import random
+
+from accelerate import Accelerator
+from datasets import Dataset
+import torch
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from trl import SFTTrainer, SFTConfig, GRPOConfig
+from trl.models import unwrap_model_for_generation
+
+from data import (
+    BaseBuilder,
+)
+from interactions.base_interaction import (
+    InteractionConfig,   
+    InteractionManager, 
+    InteractionDataProto
+)
+from interactions.singleturn_interaction import SingleTurnInteractionManager
+from interactions.multiturn_interaction import MultiTurnInteractionManager
+
+from memgen.model.modeling_memgen import MemGenModel
+from memgen.trainer.weaver_grpo_trainer import WeaverGRPOTrainer
+from memgen.trainer.trigger_grpo_trainer import TriggerGRPOTrainer
+from memgen.utils import (
+    StaticEvalRecorder,
+    DynamicEvalRecorder,
+    create_tensorboard,
+    log_trainable_params,
+    gather_objects
+)
+
+
+class MemGenRunner:
+
+    def __init__(
+        self,
+        model: MemGenModel,
+        data_builder: BaseBuilder,
+        config: dict,
+        working_dir: str,
+    ):  
+        # parse configs
+        self.config = config
+        self.working_dir = working_dir
+
+        self._parse_configs(config.get("run"))  
+        
+        # parse model
+        self.processing_class = model.tokenizer
+        self.model = model
+
+        # initialize envs and generation managers
+        self.dataset_dict = data_builder.get_dataset_dict()
+        self.env_cls = data_builder.get_env_cls()
+        self.env = self.env_cls(config.get("dataset"))
+
+        # partition datasets
+        self.weaver_train_dataset, self.trigger_train_dataset = self._parse_train_dataset(self.dataset_dict["train"])
+        self.weaver_valid_dataset, self.trigger_valid_dataset = self._parse_valid_dataset(self.dataset_dict["valid"])
+        self.test_dataset = self.dataset_dict["test"]
+        
+        self.weaver_train_dataset = self._filter_dataset(self.weaver_train_dataset)
+        self.trigger_train_dataset = self._filter_dataset(self.trigger_train_dataset)
+        self.weaver_valid_dataset = self._filter_dataset(self.weaver_valid_dataset)
+        self.trigger_valid_dataset = self._filter_dataset(self.trigger_valid_dataset)
+        
+        # initialize generation manager
+        if self.env_cls.ENV_CARD == "STATIC":
+            self.inter_cls = SingleTurnInteractionManager
+        elif self.env_cls.ENV_CARD == "DYNAMIC":
+            self.inter_cls = MultiTurnInteractionManager
+        else: 
+            raise ValueError("Unsupported environment type.")
+        
+        self.generation_manager: InteractionManager = self.inter_cls(
+            self.processing_class, self.model, self.interaction_config
+        )
+    
+    def _parse_train_dataset(self, train_dataset: Dataset) -> tuple[Dataset, Dataset]:
+        # use half size of the datatset to train the trigger
+        trigger_trainset_size = min(len(train_dataset) // 3, len(train_dataset))
+        rand_indices = random.sample(range(len(train_dataset)), trigger_trainset_size)
+        return train_dataset, train_dataset.select(rand_indices)
+    
+    def _parse_valid_dataset(self, valid_dataset: Dataset) -> tuple[Dataset, Dataset]:
+
+        trigger_validset_size = min(len(valid_dataset) // 3, len(valid_dataset))
+        rand_indices = random.sample(range(len(valid_dataset)), trigger_validset_size)
+        return valid_dataset, valid_dataset.select(rand_indices)
+
+    def _filter_dataset(self, dataset: Dataset) -> Dataset:
+        tokenizer = self.processing_class
+
+        # Determine max length based on training mode
+        max_len = 1024
+        if self.train_weaver and self.train_weaver_method == "sft":
+            max_len = self.weaver_sft_training_args.max_length
+        elif self.train_weaver and self.train_weaver_method == "grpo":
+            max_len = self.weaver_grpo_training_args.max_prompt_length
+        elif self.train_trigger and self.train_trigger_method == "grpo":
+            max_len = self.trigger_grpo_training_args.max_prompt_length
+        else:
+            raise ValueError("Wrong training mode.")
+
+        # Function to filter out samples exceeding max length
+        def filter_func(sample):
+            if "prompt" in sample and sample["prompt"] is not None:
+                prompt = tokenizer.apply_chat_template(sample["prompt"], tokenize=True)
+                return len(prompt) < max_len
+            elif "messages" in sample and sample["messages"] is not None:
+                conversation = tokenizer.apply_chat_template(sample["messages"][:2], tokenize=True)
+                return len(conversation) < max_len
+            return True 
+
+        # Apply filtering
+        dataset = dataset.filter(filter_func)
+
+        return dataset
+    
+    # ===== train weaver =====
+    def _create_weaver_trainer(self):
+
+        # SFT Trainer
+        if self.train_weaver_method == "sft":
+
+            weaver_trainer = SFTTrainer(
+                model=self.model,
+                args=self.weaver_sft_training_args,
+                train_dataset=self.weaver_train_dataset,
+                eval_dataset=self.weaver_valid_dataset,
+                processing_class=self.processing_class,
+            )
+        
+        # GRPO Trainer
+        elif self.train_weaver_method == 'grpo':
+            self.weaver_grpo_training_args.do_eval = False
+            self.weaver_grpo_training_args.eval_strategy = 'no'
+            self.generation_manager.generation_config.weaver_do_sample = True
+            self.generation_manager.generation_config.trigger_do_sample = False
+            self.generation_manager.generation_config.temperature = self.weaver_grpo_training_args.temperature
+            self.generation_manager.generation_config.max_new_tokens = self.weaver_grpo_training_args.max_completion_length
+            
+            # self.weaver_train_dataset = self.weaver_train_dataset.select(range(1600))
+            
+            weaver_trainer = WeaverGRPOTrainer(
+                model=self.model,
+                reward_funcs=[self.env_cls.compute_reward],
+                args=self.weaver_grpo_training_args,
+                train_dataset=self.weaver_train_dataset,
+                eval_dataset=self.weaver_valid_dataset,
+                processing_class=self.processing_class,
+                # --- add env into trainer ---
+                env_class=self.env_cls,
+                env_main_config=self.config.get("dataset"),
+                generation_manager=self.generation_manager,
+            )
+        else:
+            raise ValueError("Unsupported weaver training method.")
+
+        return weaver_trainer
+    
+    # ===== train trigger =====
+    def _create_trigger_trainer(self):
+        
+        if self.train_trigger_method == "grpo":
+            self.trigger_grpo_training_args.do_eval = False
+            self.trigger_grpo_training_args.eval_strategy = 'no'
+
+            self.generation_manager.generation_config.trigger_do_sample = True
+            self.generation_manager.generation_config.weaver_do_sample = False
+            self.generation_manager.generation_config.temperature = self.weaver_grpo_training_args.temperature
+            self.generation_manager.generation_config.max_new_tokens = self.weaver_grpo_training_args.max_completion_length
+            
+            trigger_trainer = TriggerGRPOTrainer(
+                model=self.model, 
+                processing_class=self.processing_class, 
+                train_dataset=self.trigger_train_dataset, 
+                eval_dataset=self.trigger_valid_dataset, 
+                reward_funcs=[self.env_cls.compute_reward],
+                args=self.trigger_grpo_training_args
+            )
+        else:
+            raise ValueError("Unsupported trigger training method.")
+
+        return trigger_trainer
+    
+    # ===== train weaver/trigger =====
+    def train(self):
+
+        if self.train_weaver:
+            trainer = self._create_weaver_trainer()
+            self.model.fix_component('trigger')
+            
+        if self.train_trigger:
+            trainer = self._create_trigger_trainer()
+            self.model.fix_component('weaver')
+
+        log_trainable_params(self.model)
+
+        try:
+            trainer.train()
+            trainer.save_model()
+        except RuntimeError as e:
+            # 检查是否是 OOM 相关的错误
+            if "OOM" in str(e) or "out of memory" in str(e).lower():
+                logging.error(f"[Runner] Training stopped due to OOM: {e}")
+                # 尝试最后一次保存
+                try:
+                    oom_dir = os.path.join(self.working_dir, "model_oom_final")
+                    logging.info(f"[Runner] Attempting to save final checkpoint to {oom_dir}")
+                    trainer.save_model(oom_dir)
+                    logging.info(f"[Runner] Final checkpoint saved successfully")
+                except Exception as save_e:
+                    logging.error(f"[Runner] Failed to save final checkpoint: {save_e}")
+                raise
+            else:
+                # 非 OOM 错误，直接抛出
+                raise
+        
+
+    # ===== evaluate =====
+    def evaluate(self):
+        self.model = self.model.to(torch.bfloat16)
+
+        evaluate_func_mapping = {
+            "STATIC": self._static_evaluate,
+            "DYNAMIC": self._dynamic_evaluate
+        }
+        evaluate_func = evaluate_func_mapping.get(self.env.ENV_CARD)
+        if evaluate_func is None:
+            raise ValueError("The env has unrecogonized ENV_CARD attribute")
+        
+        return evaluate_func()
+    
+    def _static_evaluate(self):
+
+        accelerator = Accelerator()
+
+        if accelerator.is_main_process:
+            writer = create_tensorboard(save_dir=self.working_dir)
+            save_file = os.path.join(self.interaction_config.output_dir, "answer.json")
+            recorder = StaticEvalRecorder(
+                compute_metrics=[self.env_cls.compute_reward],
+                writer=writer,
+                log_file=save_file
+            )
+        else:
+            writer = None
+            recorder = None
+
+        batch_size = self.interaction_config.batch_size
+
+        test_dataloader = accelerator.prepare(DataLoader(
+            dataset=self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            collate_fn=lambda batch: batch
+        ))
+
+        model_wrapped = accelerator.prepare_model(model=self.model, evaluation_mode=True)
+        model_wrapped.eval()
+
+        for test_batch in tqdm(test_dataloader, disable=not accelerator.is_main_process):
+            with unwrap_model_for_generation(model_wrapped, accelerator) as unwrapped_model:
+                prompts = [x["prompt"] for x in test_batch]
+                prompt_inputs = self.processing_class.apply_chat_template(
+                    prompts,
+                    add_generation_prompt=True,
+                    return_tensors="pt",
+                    padding=True,
+                    padding_side="left",
+                    add_special_tokens=True,
+                    return_dict=True
+                )
+                prompt_ids, prompt_mask = prompt_inputs["input_ids"], prompt_inputs["attention_mask"]
+                gen_batch = InteractionDataProto()
+                gen_batch.batch["input_ids"] = prompt_ids.to(accelerator.device)
+                gen_batch.batch["attention_mask"] = prompt_mask.to(accelerator.device)
+                gen_batch.no_tensor_batch["initial_prompts"] = prompts
+
+                self.generation_manager.actor_rollout_wg = unwrapped_model
+                gen_output = self.generation_manager.run_agent_loop(gen_batch)
+
+                completion_ids = gen_output.batch["responses"]
+                completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+
+            # only main rank can write the json
+            local_completions = completions
+            local_batches = test_batch
+
+            all_completions = gather_objects(local_completions)
+            all_batches = gather_objects(local_batches)
+
+            if accelerator.is_main_process:
+                for comps, batch in zip(all_completions, all_batches):
+                    recorder.record_batch(comps, batch)
+
+        accelerator.wait_for_everyone()
+
+        if accelerator.is_main_process:
+            recorder.finalize()
+            writer.close()
+
+    def _dynamic_evaluate(self):
+        
+        def _set_batch_envs(batch: list) -> tuple[list[str], list[str], list]:  # batch set envs
+            system_prompts, init_user_prompts, envs = [], [], []
+            for task_config in batch:
+                env = self.env_cls(self.config.get("dataset"))
+                system_prompt, init_user_prompt = env.set_env(task_config)
+
+                system_prompts.append(system_prompt)
+                init_user_prompts.append(init_user_prompt)
+                envs.append(env)
+            
+            return system_prompts, init_user_prompts, envs
+        
+        def _build_data_proto(
+            system_prompts: list[str], init_user_prompts: list[str], envs: list
+        ) -> InteractionDataProto:
+            messages = []
+            for system_prmopt, init_user_prompt in zip(system_prompts, init_user_prompts):
+                system_message = {"role": "system", "content": system_prmopt}
+                user_message = {"role": "user", "content": init_user_prompt}
+                init_messages = [system_message, user_message]
+                messages.append(init_messages)
+
+            data_proto = InteractionDataProto()
+            data_proto.no_tensor_batch["init_prompts"] = messages
+            data_proto.no_tensor_batch["envs"] = envs
+
+            return data_proto
+        
+        # ===== body =====
+        accelerator = Accelerator()
+
+        if accelerator.is_main_process:
+            writer = create_tensorboard(save_dir=self.working_dir) 
+            save_file = os.path.join(self.interaction_config.output_dir, "conversations.txt")
+            recorder = DynamicEvalRecorder(writer=writer, log_file=save_file)
+        else:
+            writer = None
+            recorder = None
+
+        batch_size = self.interaction_config.batch_size
+        
+        # prepare dataset and dataloader
+        test_dataloader = accelerator.prepare(DataLoader(
+            dataset=self.test_dataset, 
+            batch_size=batch_size, 
+            shuffle=False,
+            collate_fn=lambda batch: batch  # use the identity function
+        ))
+
+        # prepare model
+        model_wrapped = accelerator.prepare_model(model=self.model, evaluation_mode=True)
+        model_wrapped.eval()
+        
+        # batch generate
+        for step, test_batch in tqdm(enumerate(test_dataloader), desc="Evaluation"):
+            with unwrap_model_for_generation(
+                model_wrapped, accelerator
+            ) as unwrapped_model:
+                system_prompts, init_user_prompts, envs = _set_batch_envs(test_batch) 
+                input_data_proto = _build_data_proto(system_prompts, init_user_prompts, envs)
+                
+                self.generation_manager.actor_rollout_wg = unwrapped_model
+                outputs: InteractionDataProto = self.generation_manager.run_agent_loop(input_data_proto)
+                
+                inter_histories = outputs.no_tensor_batch["inter_histories"]
+                inter_context = self.processing_class.apply_chat_template(inter_histories, tokenize=False)
+
+            # calculate batch rewards
+            rewards = []
+            for env in input_data_proto.no_tensor_batch["envs"]:
+                reward = env.feedback()
+                rewards.append(reward)
+
+            all_contexts = gather_objects(inter_context)
+            all_rewards = gather_objects(rewards)
+
+            if accelerator.is_main_process:
+                for conts, rs in zip(all_contexts, all_rewards):
+                    recorder.record_batch(conts, rs)
+        
+        accelerator.wait_for_everyone()
+
+        if accelerator.is_main_process:
+            recorder.finalize()
+            writer.close()
+    
+    def _parse_configs(self, configs):
+        
+        self.train_weaver = configs.get("train_weaver", True)
+        self.train_trigger = configs.get("train_trigger", False)
+        
+        # --- Parse weaver training args ---
+        self.train_weaver_method = configs.get("train_weaver_method", "sft")
+        if self.train_weaver_method not in ["sft", "grpo"]:
+            raise ValueError("Unsupported weaver training method.")
+        
+        # parse weaver sft training args
+        weaver_config = configs.get("weaver", dict())
+        weaver_sft_config = weaver_config.get("sft", dict())
+        self.weaver_sft_training_args = SFTConfig(**weaver_sft_config)
+
+        # parse weaver grpo training args
+        weaver_grpo_config = weaver_config.get("grpo", dict())
+        self.weaver_grpo_training_args = GRPOConfig(**weaver_grpo_config)
+
+        # --- Parse trigger training args ---
+        trigger_config = configs.get("trigger", dict()) 
+        self.train_trigger_method = configs.get("train_trigger_method", "grpo")
+        if self.train_trigger_method not in ["grpo"]:
+            raise ValueError("Unsupported trigger training method.")
+        
+        trigger_grpo_config = trigger_config.get("grpo", dict())
+        self.trigger_grpo_training_args = GRPOConfig(**trigger_grpo_config)
+
+        # --- update training args ---
+        updated_args = {
+            "output_dir": os.path.join(self.working_dir, "model"),
+            "logging_dir": os.path.join(self.working_dir, "run"),
+            "save_strategy": "no"
+        }
+        for k, v in updated_args.items():
+            setattr(self.weaver_sft_training_args, k, v)
+            setattr(self.weaver_grpo_training_args, k, v)
+            setattr(self.trigger_grpo_training_args, k, v)
+
+        # --- parse interaction args ---
+        interaction_configs = configs.get("interaction", {})
+        self.interaction_config = InteractionConfig(
+            max_turns=interaction_configs.get("max_turns", 30),
+            max_start_length=interaction_configs.get("max_start_length", 1024),
+            max_prompt_length=interaction_configs.get("max_prompt_length", 4096),
+            max_response_length=interaction_configs.get("max_response_length", 512),
+            max_obs_length=interaction_configs.get("max_obs_length", 512),
+            temperature=interaction_configs.get("temperature", 0.0),
+            batch_size=interaction_configs.get("batch_size", 32),
+            output_dir=os.path.join(self.working_dir, "evaluate"),
+            weaver_do_sample=interaction_configs.get("weaver_do_sample", False),
+            trigger_do_sample=interaction_configs.get("trigger_do_sample", False),
+        )

MemGen-main/memgen/trainer/trigger_grpo_trainer.py

@@ -0,0 +1,390 @@
+from trl import GRPOTrainer, GRPOConfig
+from trl.data_utils import maybe_apply_chat_template 
+from trl.models import unwrap_model_for_generation, create_reference_model   
+from trl.trainer.utils import selective_log_softmax
+from transformers import (
+    PreTrainedModel, 
+    PreTrainedTokenizerBase, 
+    TrainerCallback
+)
+from peft import PeftConfig
+
+from typing import Union, Callable, Optional, Any
+from contextlib import nullcontext
+import torch
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.utils.data import Dataset
+from accelerate.utils import gather_object
+
+from interactions.base_interaction import InteractionDataProto
+from interactions.tensor_utils import TensorHelper, TensorConfig
+
+from memgen.trainer.utils import (
+    nanstd, 
+    nanmax, 
+    nanmin, 
+    generate_position_ids
+)
+from memgen.model.modeling_memgen import MemGenModel
+
+RewardFunc = Union[str, PreTrainedModel, Callable[[list, list], list[float]]]
+
+class TriggerGRPOTrainer(GRPOTrainer):
+    def __init__(
+        self,
+        model: MemGenModel,
+        processing_class: PreTrainedTokenizerBase,
+        train_dataset: Dataset,
+        eval_dataset: Dataset,
+        reward_funcs: Union[RewardFunc, list[RewardFunc]],
+        reward_processing_classes: Optional[Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]] = None,
+        args: Optional[GRPOConfig] = None,
+        callbacks: Optional[list[TrainerCallback]] = None,
+        optimizers: tuple[Optional[torch.optim.Optimizer], Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None),
+        peft_config: Optional[PeftConfig] = None,
+    ):        
+        # NOTE - Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
+        # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
+        # self.model_accepts_loss_kwargs to False to enable scaling.
+        self.model_accepts_loss_kwargs = False
+
+        super().__init__(
+            model=model,
+            args=args,
+            reward_funcs=reward_funcs,
+            reward_processing_classes=reward_processing_classes,
+            train_dataset=train_dataset,
+            eval_dataset=eval_dataset,
+            processing_class=processing_class,
+            callbacks=callbacks,
+            optimizers=optimizers,
+            peft_config=peft_config
+        )
+
+        # If PEFT configuration is not provided, create a reference model based on the initial model.
+        ref_model = create_reference_model(model.trigger)
+        self.ref_model = self.accelerator.prepare_model(ref_model, evaluation_mode=True)
+        self.tensor_fn = TensorHelper(TensorConfig(
+            pad_token_id=self.processing_class.pad_token_id,
+            max_prompt_length=self.max_prompt_length,
+            max_obs_length=None,
+            max_start_length=None
+        ))
+    
+    def _set_signature_columns_if_needed(self):
+        # NOTE - If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+        # By default, this method sets `self._signature_columns` to the model's expected inputs.
+        # In LatentProcessorSFTTrainer, we preprocess data, so using the model's signature columns doesn't work.
+        # Instead, we set them to the columns expected by the `training_step` method, hence the override.
+        pass   
+
+    def _get_per_token_logps(
+        self, 
+        model, 
+        input_ids: torch.LongTensor, 
+        attention_mask: torch.LongTensor, 
+        augmentation_mask: torch.LongTensor
+    ) -> torch.Tensor:
+        prompt_len = attention_mask.size(1) - augmentation_mask.size(1)
+        
+        assert input_ids.shape == attention_mask.shape
+        position_ids = generate_position_ids(attention_mask)
+        augmentation_logits = model.trigger(
+            input_ids=input_ids, 
+            attention_mask=attention_mask,
+            position_ids=position_ids
+        )
+        clipped_logits = augmentation_logits[:, prompt_len - 1 : -1]
+        assert clipped_logits.shape[:-1] == augmentation_mask.shape
+        
+        temp_mask = augmentation_mask.clone()
+        augmentation_valid_mask = (temp_mask == -100).clone()
+        
+        temp_mask[augmentation_valid_mask] = 0 
+        logps = selective_log_softmax(clipped_logits, temp_mask)
+        logps[augmentation_valid_mask] = 0
+
+        return logps
+    
+    def _generate_and_score_completions(
+        self, inputs: list[dict[str, Union[torch.Tensor, Any]]]
+    ) -> dict[str, Union[torch.Tensor, Any]]:
+        
+        device = self.accelerator.device
+        mode = "train" if self.model.training else "eval"
+
+        prompts = [x["prompt"] for x in inputs]
+        invalid_augmentation_id = -100
+
+        # modified: pop those keys for generation
+        batch_gen_keys = []
+        if "prompt" in inputs[0]:  # text-based raw prompt
+            batch_gen_keys.append("prompt")
+        if "tools_kwargs" in inputs[0]:  # tool-integrated     
+            batch_gen_keys.append("tools_kwargs")
+        if "interaction_kwargs" in inputs[0]:  # interaction args
+            batch_gen_keys.append("interaction_kwargs")
+        if "agent_name" in inputs[0]:  # agent name
+            batch_gen_keys.append("agent_name")    
+        if "env" in inputs[0]:  
+            batch_gen_keys.append("env")
+        
+        # build generation batch
+        gen_batch = InteractionDataProto()
+        for key in batch_gen_keys:  
+            gen_batch.no_tensor_batch[key] = [x[key] for x in inputs]
+        
+        prompts_text = [maybe_apply_chat_template(example, self.processing_class)["prompt"] for example in inputs]
+        prompt_inputs = self.processing_class(
+            text=prompts_text, return_tensors="pt", padding=True, padding_side="left", add_special_tokens=False
+        )
+               
+        prompt_ids, prompt_mask = prompt_inputs["input_ids"], prompt_inputs["attention_mask"]
+        if self.max_prompt_length is not None:
+            prompt_ids = prompt_ids[:, -self.max_prompt_length :]
+            prompt_mask = prompt_mask[:, -self.max_prompt_length :]
+
+        gen_batch.batch["input_ids"] = prompt_ids.to(device) 
+        gen_batch.batch["attention_mask"] = prompt_mask.to(device)
+
+        # Regular generation path
+        with unwrap_model_for_generation(
+            self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation
+        ) as unwrapped_model:
+            with (
+                FSDP.summon_full_params(self.model_wrapped, recurse=False)
+                if self.is_fsdp_enabled
+                else nullcontext()
+            ):
+                prompt_ids = gen_batch.batch["input_ids"]
+                prompt_mask = gen_batch.batch["attention_mask"]
+                prompt_completion_ids, augmentation_mask = unwrapped_model.generate(
+                    prompt_ids, prompt_mask, generation_config=self.generation_config, return_augmentation_mask=True
+                )
+                # Compute prompt length and extract completion ids
+                prompt_length = prompt_ids.size(1)
+                prompt_ids = prompt_completion_ids[:, :prompt_length]
+                completion_ids = prompt_completion_ids[:, prompt_length:]
+                assert completion_ids.shape == augmentation_mask.shape
+            
+            # Mask everything after the first EOS token
+            is_eos = completion_ids == self.processing_class.eos_token_id
+            eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+            eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+            sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+            completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int()  
+            completion_ids = torch.where(
+                completion_mask.bool(),                
+                completion_ids,                          
+                torch.full_like(completion_ids, self.processing_class.eos_token_id) 
+            )
+            
+            augmentation_valid_mask = completion_mask * (augmentation_mask != invalid_augmentation_id)
+            augmentation_mask = torch.where(
+                augmentation_valid_mask.bool(),         
+                augmentation_mask,                 
+                torch.full_like(augmentation_mask, invalid_augmentation_id)  
+            )
+        
+        # If a truncation-based output strategy is used, 
+        # then for any sequence that has not generated an EOS token, its loss will be ignored during computation.
+        if self.mask_truncated_completions:
+            truncated_completions = ~is_eos.any(dim=1)
+            completion_mask = completion_mask * (~truncated_completions).unsqueeze(1).int()
+        
+        # Concatenate prompt_mask with completion_mask for logit computation
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)  # (B, P + C)
+        
+        with torch.no_grad():
+            # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps
+            # old_per_token_logps == per_token_logps, so we can skip it's computation here, and use
+            # per_token_logps.detach() instead.
+            if self.num_iterations > 1 or self.args.steps_per_generation > self.args.gradient_accumulation_steps:
+                old_per_token_logps = self._get_per_token_logps( 
+                    self.model.trigger, prompt_completion_ids, attention_mask, augmentation_mask
+                )
+            else:
+                old_per_token_logps = None
+            
+            # Compute the per-token log probabilities for the reference model
+            if self.beta != 0.0:
+                if self.ref_model is not None:
+                    ref_per_token_logps = self._get_per_token_logps(
+                        self.ref_model, prompt_completion_ids, attention_mask, augmentation_mask
+                    )
+                else:
+                    with self.accelerator.unwrap_model(self.model).disable_adapter():
+                        ref_per_token_logps = self._get_per_token_logps(
+                            self.model.trigger, prompt_completion_ids, attention_mask, augmentation_mask
+                        )
+            else: 
+                ref_per_token_logps = None
+        
+        # Decode the generated completions
+        completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+        completions = completions_text
+
+        for i in range(len(inputs)):   
+            inputs[i]["augmentation_mask"] = augmentation_mask[i]
+
+        # Convert tensor to a list of lists of token IDs. This will be passed to the reward function, avoiding the need
+        # to re-tokenize completions if the reward is computed from tokens.
+        completion_ids_list = [
+            [id.item() for id, m in zip(row, mask_row) if m] for row, mask_row in zip(completion_ids, completion_mask)
+        ]
+        rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+
+        # Apply weights to each reward function's output and sum
+        rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+
+        # Compute grouped-wise rewards
+        mean_grouped_rewards = rewards.view(-1, self.num_generations).mean(dim=1)
+        std_grouped_rewards = rewards.view(-1, self.num_generations).std(dim=1)
+        is_std_zero = torch.isclose(std_grouped_rewards, torch.zeros_like(std_grouped_rewards))
+
+        # Normalize the rewards to compute the advantages
+        mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
+        std_grouped_rewards = std_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
+        advantages = rewards - mean_grouped_rewards
+        if self.scale_rewards:
+            advantages = advantages / (std_grouped_rewards + 1e-4)
+
+        # Slice to keep only the local part of the data
+        process_slice = slice(
+            self.accelerator.process_index * len(prompts),
+            (self.accelerator.process_index + 1) * len(prompts),
+        )
+        all_process_advantages = advantages.clone()  # keep the aggregated advantages for logging
+        advantages = advantages[process_slice]
+
+        # Log the metrics
+        if mode == "train":
+            self.state.num_input_tokens_seen += self.accelerator.gather(attention_mask.sum()).sum().item()
+        self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen]
+
+        # Log completion lengths, mean, min, max
+        completion_lengths = completion_mask.sum(1)
+        agg_completion_lengths = self.accelerator.gather(completion_lengths)
+        self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+        self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+        self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+        # Log augmentation lengths, mean, min, max
+        augmentation_lengths = (augmentation_mask == 1).sum(dim=1)  
+        agg_augmentation_lengths = self.accelerator.gather(augmentation_lengths)
+        self._metrics[mode]["augmentations/mean_length"].append(agg_augmentation_lengths.float().mean().item())
+        self._metrics[mode]["augmentations/min_length"].append(agg_augmentation_lengths.float().min().item())
+        self._metrics[mode]["augmentations/max_length"].append(agg_augmentation_lengths.float().max().item())
+
+        # Identify sequences that terminated with EOS and log their lengths
+        agg_terminated_with_eos = self.accelerator.gather(is_eos.any(dim=1))
+        term_completion_lengths = agg_completion_lengths[agg_terminated_with_eos]
+        clipped_completions_ratio = 1 - len(term_completion_lengths) / len(agg_completion_lengths)
+        self._metrics[mode]["completions/clipped_ratio"].append(clipped_completions_ratio)
+        if len(term_completion_lengths) == 0:  # edge case where no terminated sequences are found
+            term_completion_lengths = torch.zeros(1, device=device)
+        self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+        self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+        self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+        
+        # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values)
+        for i, reward_func_name in enumerate(self.reward_func_names):
+            mean_rewards = torch.nanmean(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards)
+            std_rewards = nanstd(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_rewards)
+        self._metrics[mode]["reward"].append(mean_grouped_rewards.mean().item())
+        self._metrics[mode]["reward_std"].append(std_grouped_rewards.mean().item())
+        self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item())
+
+        # Log prompt and completion texts
+        self._logs["prompt"].extend(gather_object(prompts_text))
+        self._logs["completion"].extend(gather_object(completions_text))
+        for i, name in enumerate(self.reward_func_names):
+            self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist())
+        self._logs["advantages"].extend(all_process_advantages.tolist())
+
+        return {
+            "prompt_ids": prompt_ids,
+            "prompt_mask": prompt_mask,
+            "completion_ids": completion_ids,
+            "completion_mask": completion_mask,
+            "augmentation_mask": augmentation_mask,
+            "advantages": advantages,
+            "old_per_token_logps": old_per_token_logps,
+            "ref_per_token_logps": ref_per_token_logps,
+        }
+
+    def _compute_loss(self, model, inputs):
+        # Compute the per-token log probabilities for the model
+        prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+        completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+        augmentation_mask = inputs["augmentation_mask"]
+        input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+
+        per_token_logps = self._get_per_token_logps(model, input_ids, attention_mask, augmentation_mask)
+        
+        # Compute the KL divergence between the model and the reference model
+        if self.beta != 0.0:
+            ref_per_token_logps = inputs["ref_per_token_logps"]
+            per_token_kl = (
+                torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
+            )
+
+        # Compute the loss
+        advantages = inputs["advantages"]
+        # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps
+        # old_per_token_logps == per_token_logps, so we can skip it's computation
+        # (see _generate_and_score_completions) and use per_token_logps.detach() instead.
+        old_per_token_logps = (
+            per_token_logps.detach() if inputs["old_per_token_logps"] is None else inputs["old_per_token_logps"]
+        )
+        coef_1 = torch.exp(per_token_logps - old_per_token_logps)
+        coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+
+        # Two-sided clipping
+        if self.args.delta is not None:
+            coef_1 = torch.clamp(coef_1, max=self.args.delta)
+
+        per_token_loss1 = coef_1 * advantages.unsqueeze(1)
+        per_token_loss2 = coef_2 * advantages.unsqueeze(1)
+        per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+        if self.beta != 0.0:
+            per_token_loss = per_token_loss + self.beta * per_token_kl
+        
+        augmentation_valid_mask = (augmentation_mask != -100)
+        if self.loss_type == "grpo":
+            loss = ((per_token_loss * augmentation_valid_mask).sum(-1) / augmentation_valid_mask.sum(-1).clamp(min=1.0)).mean()
+        elif self.loss_type == "bnpo":
+            loss = (per_token_loss * augmentation_valid_mask).sum() / augmentation_valid_mask.sum().clamp(min=1.0)
+        elif self.loss_type == "dr_grpo":
+            loss = (per_token_loss * augmentation_valid_mask).sum() / (augmentation_valid_mask.size(0) * self.max_completion_length)
+        else:
+            raise ValueError(f"Unknown loss type: {self.loss_type}")
+
+        # Log the metrics
+        mode = "train" if self.model.training else "eval"
+
+        if self.beta != 0.0:
+            mean_kl = (per_token_kl * augmentation_valid_mask).sum() / augmentation_valid_mask.sum()
+            self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+        # Compute the clipped probability ratios
+        is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages.unsqueeze(1) < 0)
+        is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages.unsqueeze(1) > 0)
+        is_region_clipped = is_low_clipped | is_high_clipped
+
+        low_clip = (is_low_clipped * augmentation_valid_mask).sum() / augmentation_valid_mask.sum()
+        high_clip = (is_high_clipped * augmentation_valid_mask).sum() / augmentation_valid_mask.sum()
+        clip_ratio = (is_region_clipped * augmentation_valid_mask).sum() / augmentation_valid_mask.sum()
+
+        gathered_low_clip = self.accelerator.gather(low_clip)
+        self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+        gathered_high_clip = self.accelerator.gather(high_clip)
+        self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+        gathered_clip_ratio = self.accelerator.gather(clip_ratio)
+        self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+        return loss

MemGen-main/memgen/trainer/utils.py

@@ -0,0 +1,52 @@
+import torch
+
+# torch.nanstd doesn't exist, so we define it here
+def nanstd(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Compute the standard deviation of a tensor, ignoring NaNs. This function only supports 1D tensors.
+
+    Args:
+        tensor (`torch.Tensor`):
+            Input tensor of shape `(N,)`.
+
+    Returns:
+        `torch.Tensor`:
+            Standard deviation of the tensor, ignoring NaNs.
+    """
+    variance = torch.nanmean((tensor - torch.nanmean(tensor, keepdim=True)) ** 2)  # Compute variance ignoring NaNs
+    count = torch.sum(~torch.isnan(tensor))  # Count of non-NaN values
+    variance *= count / (count - 1)  # Bessel's correction
+    return torch.sqrt(variance)
+
+def nanmax(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Compute the maximum value of a tensor, ignoring NaNs. This function only supports 1D tensors.
+
+    Args:
+        tensor (`torch.Tensor`): Input tensor of shape `(N,)`.
+
+    Returns:
+        `torch.Tensor`: Maximum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN.
+    """
+    if torch.isnan(tensor).all():
+        return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device)
+    return torch.max(tensor[~torch.isnan(tensor)])
+
+def nanmin(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Compute the minimum value of a tensor, ignoring NaNs. This function only supports 1D tensors.
+
+    Args:
+        tensor (`torch.Tensor`): Input tensor of shape `(N,)`.
+
+    Returns:
+        `torch.Tensor`: Minimum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN.
+    """
+    if torch.isnan(tensor).all():
+        return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device)
+    return torch.min(tensor[~torch.isnan(tensor)])
+
+def generate_position_ids(attention_mask):
+    position_ids = (attention_mask.cumsum(-1) - 1).clamp(min=0)
+    position_ids.masked_fill_(attention_mask == 0, 0)
+    return position_ids

MemGen-main/memgen/trainer/weaver_grpo_trainer.py

@@ -0,0 +1,466 @@
+from contextlib import nullcontext
+import logging
+import os
+from typing import Any, Callable, Optional, Union
+
+import torch
+from accelerate.utils import gather_object
+from datasets import Dataset, IterableDataset
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from transformers import (
+    PreTrainedModel,
+    PreTrainedTokenizerBase,
+    ProcessorMixin,
+    TrainerCallback,
+)
+from transformers.utils import is_peft_available
+from trl import GRPOTrainer, GRPOConfig
+from trl.trainer.utils import selective_log_softmax
+from trl.data_utils import maybe_apply_chat_template
+from trl.models import unwrap_model_for_generation
+if is_peft_available():
+    from peft import PeftConfig
+
+from interactions.base_interaction import (
+    InteractionManager, InteractionDataProto
+)
+from data.base_env import StaticEnv, DynamicEnv
+
+from .utils import (
+    nanstd, nanmax, nanmin
+)
+from ..model.modeling_memgen import MemGenModel
+
+# What we call a reward function is a callable that takes a list of prompts and completions and returns a list of
+# rewards. When it's a string, it's a model ID, so it's loaded as a pretrained model.
+RewardFunc = Union[str, PreTrainedModel, Callable[[list, list], list[float]]]
+
+class WeaverGRPOTrainer(GRPOTrainer):
+
+    def __init__(
+        self,
+        model: MemGenModel,
+        reward_funcs: Union[RewardFunc, list[RewardFunc]],
+        args: Optional[GRPOConfig] = None,
+        train_dataset: Optional[Union[Dataset, IterableDataset]] = None,
+        eval_dataset: Optional[Union[Dataset, IterableDataset, dict[str, Union[Dataset, IterableDataset]]]] = None,
+        processing_class: Optional[Union[PreTrainedTokenizerBase, ProcessorMixin]] = None,
+        reward_processing_classes: Optional[Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]] = None,
+        callbacks: Optional[list[TrainerCallback]] = None,
+        optimizers: tuple[Optional[torch.optim.Optimizer], Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None),
+        peft_config: Optional["PeftConfig"] = None,
+        env_class = None,   # env main class
+        env_main_config = None,  # configs to initialize an env object
+        generation_manager: InteractionManager = None  # manage the interaction between agent and env
+    ):
+        super().__init__(
+            model, 
+            reward_funcs,
+            args,
+            train_dataset,
+            eval_dataset,
+            processing_class,
+            reward_processing_classes,
+            callbacks,
+            optimizers,
+            peft_config
+        )
+        
+        self.env_class = env_class
+        self.env_main_config = env_main_config
+        self.generation_manager = generation_manager
+
+        self.generation_manager.config.max_prompt_length
+        
+        # assert self.max_prompt_length == generation_manager.config.max_start_length
+        # assert self.max_completion_length == generation_manager.config.max_response_length
+        # assert self.temperature == generation_manager.config.temperature   
+    
+    def _build_multiturn_envs(self, inputs: list[dict[str, Union[torch.Tensor, Any]]]) -> tuple[list[list[dict]], list]:
+        init_messages, envs = [], []
+
+        for task_config in inputs:
+            env: DynamicEnv = self.env_class(self.env_main_config)
+            system_prompt, init_user_prompt = env.set_env(task_config)
+            
+            system_message = {"role": "system", "content": system_prompt}
+            init_user_message = {"role": "user", "content": init_user_prompt}
+            
+            init_messages.append([system_message, init_user_message])
+            envs.append(env)
+        
+        return init_messages, envs
+    
+    def _get_per_token_logps(
+        self, model, 
+        input_ids: torch.Tensor, 
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor, 
+        logits_to_keep: int,
+        batch_size: int = None
+    ) -> torch.Tensor:
+        batch_size = batch_size or input_ids.size(0)  # Chunk inputs into smaller batches to reduce memory peak
+        all_logps = []
+        supervise_masks = []   
+        for start in range(0, input_ids.size(0), batch_size):
+            input_ids_batch = input_ids[start : start + batch_size]
+            attention_mask_batch = attention_mask[start : start + batch_size]
+
+            # Build model inputs - check if the model supports logits_to_keep (some models and VLMs don't)
+            model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch, "labels": labels}
+
+            # Only add logits_to_keep if the model supports it
+            if "logits_to_keep" in self.model_kwarg_keys:
+                # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+                model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+            outputs = model(**model_inputs)
+            logits = outputs.logits
+            labels = outputs.supervised_labels
+            
+            # Exclude the last value: it corresponds to the next token pred
+            logits = logits[:, :-1, :]  # (B, L-1, H)
+            # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+            logits = logits[:, -logits_to_keep:, :]  # (B, logits_to_keep, H)
+            # Divide logits by sampling temperature.
+            # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details
+            logits = logits / self.temperature
+
+            completion_ids = input_ids_batch[:, -logits_to_keep:]
+            logps = selective_log_softmax(logits, completion_ids)  # compute logprobs
+            all_logps.append(logps)
+            
+            labels = labels[:, -logits_to_keep:]
+            mask = (labels != -100).long()  
+            supervise_masks.append(mask)
+
+        logps = torch.cat(all_logps, dim=0)
+        masks = torch.cat(supervise_masks, dim=0)
+        return logps, masks
+
+
+    # NOTE - currently we only deal with text input and leave multimodal as a feature work
+    def _generate_and_score_completions(
+        self, inputs: list[dict[str, Union[torch.Tensor, Any]]]  # batch_size * num_generations
+    ) -> dict[str, Union[torch.Tensor, Any]]:
+
+        device = self.accelerator.device
+        mode = "train" if self.model.training else "eval"
+
+        # build no-tensor part
+        batch_gen_keys = []
+        if "prompt" in inputs[0]:  # text-based raw prompt
+            batch_gen_keys.append("prompt")
+        if "tools_kwargs" in inputs[0]:  # tool-integrated     
+            batch_gen_keys.append("tools_kwargs")
+        if "interaction_kwargs" in inputs[0]:  # interaction args
+            batch_gen_keys.append("interaction_kwargs")
+        if "agent_name" in inputs[0]:  # agent name
+            batch_gen_keys.append("agent_name")    
+
+        gen_batch = InteractionDataProto()
+        for key in batch_gen_keys:  
+            gen_batch.no_tensor_batch[key] = [x[key] for x in inputs]
+        
+        # Single-turn env
+        if issubclass(self.env_class, StaticEnv):
+            prompts_text = [maybe_apply_chat_template(example, self.processing_class)["prompt"] for example in inputs]
+            prompt_inputs = self.processing_class(
+                text=prompts_text, return_tensors="pt", padding=True, padding_side="left", add_special_tokens=False
+            )
+                
+            prompts, prompt_mask = prompt_inputs["input_ids"].to(device), prompt_inputs["attention_mask"].to(device)
+            if self.max_prompt_length is not None:
+                prompts = prompts[:, -self.max_prompt_length :]
+                prompt_mask = prompt_mask[:, -self.max_prompt_length :]
+
+            gen_batch.batch["input_ids"] = prompts 
+            gen_batch.batch["attention_mask"] = prompt_mask
+        # Multi-turn env
+        elif issubclass(self.env_class, DynamicEnv):
+            init_prompts, envs = self._build_multiturn_envs(inputs)
+            gen_batch.no_tensor_batch["init_prompts"] = init_prompts
+            gen_batch.no_tensor_batch["envs"] = envs
+            
+            for example, env in zip(inputs, envs):
+                example["envs"] = env
+        else:
+            raise ValueError("Unsupported environment type")
+    
+        # Regular generation path
+        with unwrap_model_for_generation(
+            self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation
+        ) as unwrapped_model:
+            with (
+                FSDP.summon_full_params(self.model_wrapped, recurse=False)
+                if self.is_fsdp_enabled
+                else nullcontext()
+            ):
+                # Use GenerationManager to coordinate the interaction between the agent and the environment
+                self.generation_manager.actor_rollout_wg = unwrapped_model  
+                final_gen_batch_output = self.generation_manager.run_agent_loop(gen_batch=gen_batch)
+        
+        # parse outputs
+        prompts = final_gen_batch_output.batch["prompts"].to(device)  # prompt ids
+        completion_ids = final_gen_batch_output.batch["responses"].to(device)  # completion ids
+        prompt_completion_ids = final_gen_batch_output.batch["input_ids"].to(device)  # prompt and completion ids
+        attention_mask = final_gen_batch_output.batch["attention_mask"].to(device)  # attention_mask on prompt and response
+        prompt_mask = attention_mask[:, :prompts.size(1)]  
+        completion_mask = final_gen_batch_output.batch["info_mask"][:, prompts.size(1):].to(device) 
+        is_eos = completion_ids == self.eos_token_id
+        assert completion_ids.shape == completion_mask.shape
+
+        # Construct labels: Supervise only the agent response portion.
+        prompt_labels = torch.full(prompt_mask.shape, -100, device=device)
+        completion_labels = torch.where(completion_mask == 1, completion_ids, -100)
+        labels = torch.cat([prompt_labels, completion_labels], dim=1)
+        
+        # Convert tensor to a list of lists of token IDs. This will be passed to the reward function, avoiding the need
+        # to re-tokenize completions if the reward is computed from tokens.
+        completion_ids_list = [
+            [id.item() for id, m in zip(row, mask_row) if m] for row, mask_row in zip(completion_ids, completion_mask)
+        ]
+
+        # Sum along sequence dimension (dim=1) to get completion length per sequence, used for logging
+        completion_lengths = completion_mask.sum(1)
+
+        logits_to_keep = completion_mask.size(1)
+
+        # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask
+        if self.mask_truncated_completions:
+            truncated_completions = ~is_eos.any(dim=1)
+            completion_mask = completion_mask * (~truncated_completions).unsqueeze(1).int()
+
+        with torch.no_grad():
+            # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps
+            # old_per_token_logps == per_token_logps, so we can skip it's computation here, and use
+            # per_token_logps.detach() instead.
+            if self.num_iterations > 1 or self.args.steps_per_generation > self.args.gradient_accumulation_steps:
+                old_per_token_logps, old_supervise_mask = self._get_per_token_logps( 
+                    self.model, prompt_completion_ids, attention_mask, labels, logits_to_keep
+                )
+            else:
+                old_per_token_logps, old_supervise_mask = None, None
+            
+            # Compute the per-token log probabilities for the reference model
+            if self.beta != 0.0:
+                if self.ref_model is not None:
+                    ref_per_token_logps, ref_supervise_mask = self._get_per_token_logps(
+                        self.ref_model, prompt_completion_ids, attention_mask, labels, logits_to_keep
+                    )
+                else:
+                    with self.accelerator.unwrap_model(self.model).disable_adapter():
+                        ref_per_token_logps, ref_supervise_mask = self._get_per_token_logps(
+                            self.model, prompt_completion_ids, attention_mask, labels, logits_to_keep
+                        )
+            else: 
+                ref_per_token_logps, ref_supervise_mask = None, None
+        
+        # Decode the generated completions
+        completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+        completions = completions_text
+        
+        # compute rewards
+        rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+
+        # Apply weights to each reward function's output and sum
+        rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+
+        # Compute grouped-wise rewards
+        mean_grouped_rewards = rewards.view(-1, self.num_generations).mean(dim=1)
+        std_grouped_rewards = rewards.view(-1, self.num_generations).std(dim=1)
+        is_std_zero = torch.isclose(std_grouped_rewards, torch.zeros_like(std_grouped_rewards))
+
+        # Normalize the rewards to compute the advantages
+        mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
+        std_grouped_rewards = std_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
+        advantages = rewards - mean_grouped_rewards
+        if self.scale_rewards:
+            advantages = advantages / (std_grouped_rewards + 1e-4)
+
+        # Slice to keep only the local part of the data
+        process_slice = slice(
+            self.accelerator.process_index * len(prompts),
+            (self.accelerator.process_index + 1) * len(prompts),
+        )
+        all_process_advantages = advantages.clone()  # keep the aggregated advantages for logging
+        advantages = advantages[process_slice]
+
+        # Log the metrics
+        if mode == "train":
+            self.state.num_input_tokens_seen += self.accelerator.gather(attention_mask.sum()).sum().item()
+        self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen]
+
+        # Log completion lengths, mean, min, max
+        agg_completion_lengths = self.accelerator.gather(completion_lengths)
+        self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item())
+        self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item())
+        self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item())
+
+        # Identify sequences that terminated with EOS and log their lengths
+        agg_terminated_with_eos = self.accelerator.gather(is_eos.any(dim=1))
+        term_completion_lengths = agg_completion_lengths[agg_terminated_with_eos]
+        clipped_completions_ratio = 1 - len(term_completion_lengths) / len(agg_completion_lengths)
+        self._metrics[mode]["completions/clipped_ratio"].append(clipped_completions_ratio)
+        if len(term_completion_lengths) == 0:  # edge case where no terminated sequences are found
+            term_completion_lengths = torch.zeros(1, device=device)
+        self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item())
+        self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item())
+        self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item())
+        
+        # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values)
+        for i, reward_func_name in enumerate(self.reward_func_names):
+            mean_rewards = torch.nanmean(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards)
+            std_rewards = nanstd(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_rewards)
+        self._metrics[mode]["reward"].append(mean_grouped_rewards.mean().item())
+        self._metrics[mode]["reward_std"].append(std_grouped_rewards.mean().item())
+        self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item())
+
+        # Log prompt and completion texts
+        # self._logs["prompt"].extend(gather_object(prompts_text))
+        self._logs["completion"].extend(gather_object(completions_text))
+        for i, name in enumerate(self.reward_func_names):
+            self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist())
+        self._logs["advantages"].extend(all_process_advantages.tolist())
+
+        return {
+            "prompt_ids": prompts,
+            "prompt_mask": prompt_mask,
+            "completion_ids": completion_ids,
+            "completion_mask": completion_mask,
+            "advantages": advantages,
+            "old_per_token_logps": old_per_token_logps,
+            "old_supervise_mask": old_supervise_mask,   
+            "ref_per_token_logps": ref_per_token_logps,
+            "ref_supervise_mask": ref_supervise_mask
+        }
+
+
+    def _compute_loss(self, model, inputs):
+        device = self.accelerator.device
+
+        prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+        completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+        old_supervise_mask, ref_supervise_mask = inputs["old_supervise_mask"], inputs["ref_supervise_mask"]
+        input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+
+        prompt_labels = torch.full(prompt_mask.shape, -100, device=device)
+        completion_labels = torch.where(completion_mask == 1, completion_ids, -100)
+        labels = torch.cat([prompt_labels, completion_labels], dim=1)
+        logits_to_keep = completion_labels.size(1)
+        
+        assert prompt_ids.shape == prompt_mask.shape
+        assert completion_ids.shape == completion_mask.shape
+        assert input_ids.shape == attention_mask.shape == labels.shape
+        per_token_logps, supervise_mask = self._get_per_token_logps(model, input_ids, attention_mask, labels, logits_to_keep)
+        
+        # Compute the KL divergence between the model and the reference model
+        if self.beta != 0.0:
+            ref_per_token_logps = inputs["ref_per_token_logps"]
+            per_token_kl = (
+                torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
+            )
+
+        # Compute the loss
+        advantages = inputs["advantages"]
+        # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps
+        # old_per_token_logps == per_token_logps, so we can skip it's computation
+        # (see _generate_and_score_completions) and use per_token_logps.detach() instead.
+        old_per_token_logps = (
+            per_token_logps.detach() if inputs["old_per_token_logps"] is None else inputs["old_per_token_logps"]
+        )
+        coef_1 = torch.exp(per_token_logps - old_per_token_logps)
+        coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+
+        # Two-sided clipping
+        if self.args.delta is not None:
+            coef_1 = torch.clamp(coef_1, max=self.args.delta)
+
+        per_token_loss1 = coef_1 * advantages.unsqueeze(1)
+        per_token_loss2 = coef_2 * advantages.unsqueeze(1)
+        per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+        if self.beta != 0.0:
+            per_token_loss = per_token_loss + self.beta * per_token_kl
+        
+        if old_supervise_mask is None:
+            old_supervise_mask = supervise_mask
+        if ref_supervise_mask is None:
+            ref_supervise_mask = supervise_mask
+        # Consistency check: The positions that are supervised must be a subset of the completion mask.
+        assert (
+            torch.all(supervise_mask <= completion_mask) and
+            torch.all(old_supervise_mask <= completion_mask) and
+            torch.all(ref_supervise_mask <= completion_mask)
+        )
+        supervised_mask = completion_mask * supervise_mask * old_supervise_mask * ref_supervise_mask  
+
+        if self.loss_type == "grpo":
+            loss = ((per_token_loss * supervised_mask).sum(-1) / supervised_mask.sum(-1).clamp(min=1.0)).mean()
+        elif self.loss_type == "bnpo":
+            loss = (per_token_loss * supervised_mask).sum() / supervised_mask.sum().clamp(min=1.0)
+        elif self.loss_type == "dr_grpo":
+            loss = (per_token_loss * supervised_mask).sum() / (supervised_mask.size(0) * self.max_completion_length)
+        else:
+            raise ValueError(f"Unknown loss type: {self.loss_type}")
+
+        # Log the metrics
+        mode = "train" if self.model.training else "eval"
+
+        if self.beta != 0.0:
+            mean_kl = (per_token_kl * supervised_mask).sum() / supervised_mask.sum()
+            self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+        # Compute the clipped probability ratios
+        is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages.unsqueeze(1) < 0)
+        is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages.unsqueeze(1) > 0)
+        is_region_clipped = is_low_clipped | is_high_clipped
+
+        low_clip = (is_low_clipped * supervised_mask).sum() / supervised_mask.sum()
+        high_clip = (is_high_clipped * supervised_mask).sum() / supervised_mask.sum()
+        clip_ratio = (is_region_clipped * supervised_mask).sum() / supervised_mask.sum()
+
+        gathered_low_clip = self.accelerator.gather(low_clip)
+        self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+        gathered_high_clip = self.accelerator.gather(high_clip)
+        self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+        gathered_clip_ratio = self.accelerator.gather(clip_ratio)
+        self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+        return loss
+
+    def training_step(self, model, inputs, num_items_in_batch=None):
+        """
+        重写 training_step 以捕获 OOM 异常并保存 checkpoint
+        """
+        try:
+            # 调用父类的 training_step
+            loss = super().training_step(model, inputs, num_items_in_batch)
+            return loss
+        except torch.cuda.OutOfMemoryError as e:
+            # OOM 发生时保存 checkpoint
+            logging.error(f"[OOM] CUDA OutOfMemoryError occurred at step {self.state.global_step}")
+            logging.error(f"[OOM] Error message: {str(e)}")
+            
+            # 清理缓存以释放内存
+            torch.cuda.empty_cache()
+            
+            # 保存 emergency checkpoint
+            oom_ckpt_dir = os.path.join(self.args.output_dir, f"oom_checkpoint_step_{self.state.global_step}")
+            logging.info(f"[OOM] Saving emergency checkpoint to {oom_ckpt_dir}")
+            
+            try:
+                self.save_model(oom_ckpt_dir)
+                logging.info(f"[OOM] Emergency checkpoint saved successfully")
+            except Exception as save_error:
+                logging.error(f"[OOM] Failed to save checkpoint: {save_error}")
+            
+            # 重新抛出异常，让训练停止
+            raise RuntimeError(
+                f"Training stopped due to OOM at step {self.state.global_step}. "
+                f"Emergency checkpoint saved to {oom_ckpt_dir}. "
+                f"You can resume training from this checkpoint."
+            ) from e

MemGen-main/memgen/utils.py

@@ -0,0 +1,268 @@
+from dataclasses import dataclass, field
+import glob
+import json
+import logging
+import os
+import shutil
+from typing import Optional, Callable, Dict, List
+
+from safetensors import safe_open
+import torch.nn as nn
+from torch.utils.tensorboard import SummaryWriter
+
+
+# ===== chat template =====
+
+# from https://huggingface.co/HuggingFaceTB/SmolLM3-3B/blob/main/chat_template.jinja
+CONVERSATION_TEMPLATE = r"""
+{# ───── main loop ───── #}
+{%- for message in messages -%}
+    {%- set content = message.content if message.content is string else "" -%}
+    {%- if (message.role == "user") or (message.role == "system") -%}
+        {{ "<|im_start|>" + message.role + "\n"  + content + "<|im_end|>\n" }}
+    {%- elif message.role == "assistant" -%}
+        {%- generation -%}
+        {{ "<|im_start|>assistant\n" + content + "<|im_end|>\n" }}
+        {%- endgeneration -%}
+    {%- elif message.role == "tool" -%}
+    {{ "<|im_start|>" + "user\n"  + content + "<|im_end|>\n" }}
+    {%- endif -%}
+{%- endfor -%}
+{# ───── generation prompt ───── #}
+{%- if add_generation_prompt -%}
+    {{ "<|im_start|>assistant\n" }}
+{%- endif -%}
+""".strip()
+
+# ===== torch part =====
+def load_state_dict_from_safetensor(model_path) -> Dict:
+    """Load a safetensor file from the given path and return a state_dict.
+
+    Args:
+        model_path (str): Path to the safetensor file.
+
+    Returns:
+        Dict[str, torch.Tensor]: A dictionary of model parameters, 
+        where keys are parameter names and values are corresponding tensors.
+    """
+    model_state_dict = {}
+    with safe_open(model_path, framework="pt") as f:
+        for key in f.keys():
+            model_state_dict[key] = f.get_tensor(key)
+    return model_state_dict
+
+def fix_model_parameters(model: nn.Module):
+    """Freeze all parameters of the given model.
+
+    Args:
+        model (nn.Module): The PyTorch model whose parameters will be frozen.
+    """
+    for parameter in model.parameters():
+        parameter.requires_grad = False
+
+def open_model_parameters(model: nn.Module):
+    """Unfreeze all parameters of the given model.
+
+    Args:
+        model (nn.Module): The PyTorch model whose parameters will be unfrozen.
+    """
+    for parameter in model.parameters():
+        parameter.requires_grad = True
+
+def log_trainable_params(model: nn.Module):
+    """Log all trainable parameters of the given model.
+
+    Args:
+        model (nn.Module): The PyTorch model to inspect.
+    """
+    logging.info("Trainable parameters in the model:")
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            logging.info(f"  {name}: {param.numel()} params, shape={param.shape}")
+
+
+
+# ===== Eval Part =====
+@dataclass
+class StaticEvalRecorder:
+    compute_metrics: List[Callable[[str, str, str], float]] = field(default_factory=list)
+    log_file: Optional[str] = None
+    writer: Optional[object] = None
+
+    # Internal storage
+    metric_sums: Dict[str, float] = field(init=False)
+    metric_counts: Dict[str, int] = field(init=False)
+
+    def __post_init__(self):
+        self.metric_sums = {metric.__name__: 0.0 for metric in self.compute_metrics}
+        self.metric_counts = {metric.__name__: 0 for metric in self.compute_metrics}
+        if self.log_file:
+            os.makedirs(os.path.dirname(self.log_file), exist_ok=True)
+            with open(self.log_file, 'w') as f:
+                f.write('')  # Clear file
+
+    def record_batch(self, completions: List[str], examples: List[Dict]):
+        """Record results for a batch of model outputs.
+
+        Args:
+            completions (List[str]): The model's answers (outputs).
+            examples (List[Dict]): Each completion's corresponding question and related attributes.
+                Each example is expected to contain the keys: "prompt" and "solution".
+        """
+        # Extract all keys from the first example
+        keys = [key for key in examples[0]]
+        # Build kwargs for metrics computation (one list per field)
+        reward_kwargs = {key: [example[key] for example in examples] for key in keys}
+        reward_kwargs['completions'] = completions
+        
+        # Compute all metrics in batch
+        batched_results = {}
+        for metric in self.compute_metrics:  # iterate over each metric function
+            metric_name = metric.__name__   # use function name as metric name
+            batched_scores = metric(**reward_kwargs)  # compute scores for the entire batch
+            batched_results[metric_name] = batched_scores
+        
+        # Record experiment results for each example
+        for i, (completion, example) in enumerate(zip(completions, examples)):
+            # Collect the metric results for this specific example
+            metrics_result = {
+                metric_name: batched_results[metric_name][i]
+                for metric_name in batched_results
+            }
+
+            # Update running totals for metrics
+            for metric_name, score in metrics_result.items():
+                self.metric_sums[metric_name] += score
+                self.metric_counts[metric_name] += 1
+            
+            # Create a log record with prompt, solution, completion, and metrics
+            prompt = example.get("prompt", "")
+            solution = example.get("solution", "")
+            record = {
+                'prompt': prompt,
+                'solution': solution,
+                'completion': completion,
+                'metrics': metrics_result
+            }
+
+            # Write the record into a log file (if available)
+            if self.log_file:
+                with open(self.log_file, 'a') as f:
+                    f.write(json.dumps(record, ensure_ascii=False) + '\n')
+            
+            # Update TensorBoard metrics (if writer is available)
+            if self.writer:
+                mean_metrics = self.get_mean_metrics()  # get average metrics across all data so far
+                for name, value in mean_metrics.items():
+                    self.writer.add_scalar(name, value, global_step=self.metric_counts[name])
+
+
+    def get_mean_metrics(self) -> Dict[str, float]:
+        return {
+            name: (self.metric_sums[name] / self.metric_counts[name]) if self.metric_counts[name] > 0 else 0.0
+            for name in self.metric_sums
+        }
+
+    def finalize(self):
+        mean_metrics = self.get_mean_metrics()
+        final_record = {
+            'summary_metrics': mean_metrics
+        }
+
+        if self.log_file:
+            with open(self.log_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(final_record, ensure_ascii=False) + '\n')
+
+        if self.writer:
+            mean_metrics = self.get_mean_metrics()
+            for name, value in mean_metrics.items():
+                self.writer.add_scalar(name + "_final", value, global_step=self.metric_counts[name])
+
+
+@dataclass
+class DynamicEvalRecorder:
+    log_file: Optional[str] = None  # path to the txt log file
+    writer: object = field(default=None)  # TensorBoard SummaryWriter
+
+    def __post_init__(self):
+        if self.log_file is None:
+            raise ValueError("log_file path must be provided")
+
+        # Ensure the directory for the log file exists
+        os.makedirs(os.path.dirname(self.log_file), exist_ok=True)
+        self.logger = logging.getLogger("DynamicEvalRecorder")
+
+        # Internal counters
+        self._total_reward = 0.0
+        self._count = 0
+
+        # Initialize the file (clear previous content if any)
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            f.write("DynamicEvalRecorder Log\n\n")
+
+    def record_batch(self, conversations: List[str], rewards: List[float]):
+        """Record a batch of conversations and their associated rewards.
+
+        Args:
+            conversations (List[str]): List of conversation texts.
+            rewards (List[float]): List of reward values corresponding to conversations.
+        """
+        if len(conversations) != len(rewards):
+            raise ValueError("conversations and rewards must have the same length")
+
+        # Append batch results to the log file
+        with open(self.log_file, "a", encoding="utf-8") as f:
+            for conv, rew in zip(conversations, rewards):
+                f.write(f"Conversation:\n{conv}\n")
+                f.write(f"Reward: {rew:.4f}\n")
+                f.write("-" * 40 + "\n")
+
+                # Update statistics
+                self._total_reward += rew
+                self._count += 1
+
+        # Compute running average reward
+        avg_reward = self._total_reward / self._count if self._count > 0 else 0.0
+
+        # Write running average to TensorBoard
+        if self.writer is not None:
+            self.writer.add_scalar("reward/avg", avg_reward, self._count)
+
+        # Log summary info
+        self.logger.info(f"Recorded {len(conversations)} items, avg_reward={avg_reward:.4f}")
+
+    def finalize(self):
+        """Finalize evaluation: write final average reward to both log file and TensorBoard."""
+        # Compute final average reward
+        avg_reward = self._total_reward / self._count if self._count > 0 else 0.0
+
+        # Append final result to log file
+        with open(self.log_file, "a", encoding="utf-8") as f:
+            f.write("\nFinal Results\n")
+            f.write("=" * 40 + "\n")
+            f.write(f"Average Reward: {avg_reward:.4f}\n")
+
+        # Write final result to TensorBoard
+        if self.writer:
+            self.writer.add_scalar("ave_reward_final", avg_reward, global_step=self._count)
+
+
+# --- helper functions ---
+def create_tensorboard(save_dir: str):
+    log_dir = os.path.join(save_dir, "runs")
+    writer = SummaryWriter(log_dir=log_dir)
+    return writer
+
+def remove_trainer_checkpoints(trainer_output_dir):
+    ckpt_paths = glob.glob(os.path.join(trainer_output_dir, "checkpoint-*"))
+    for ckpt in ckpt_paths:
+        shutil.rmtree(ckpt, ignore_errors=True)    
+
+import torch.distributed as dist
+
+def gather_objects(obj):
+    if not dist.is_initialized():
+        return obj
+    gathered = [None for _ in range(dist.get_world_size())]
+    dist.all_gather_object(gathered, obj)
+    return gathered

MemGen-main/scripts/eval.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+# options:
+# - Qwen/Qwen2.5-1.5B-Instruct
+# - HuggingFaceTB/SmolLM3-3B
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+
+# Dataset configs
+DATASET_NAME="kodcode"  # gsm8k, gpqa, kodcode, triviaqa
+
+# MemGen configs
+
+# Augmentation configs:
+# - For gsm8k, gpqa, kodcode: MAX_PROMPT_AUG_NUM=1, MAX_INFERENCE_AUG_NUM=5
+# - For triviaqa:             MAX_PROMPT_AUG_NUM=8, MAX_INFERENCE_AUG_NUM=0
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=16
+INFERENCE_LATENTS_LEN=16
+
+BATCH_SIZE=4
+
+# Trained model path: 
+# - Must point to a checkpoint file ending with .safetensors (e.g. <output_dir>/model.safetensors)
+# - Required when evaluating the model
+LOAD_MODEL_PATH=""
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/qwen2_5_gsm8k_grpo.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="gsm8k"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=8
+INFERENCE_LATENTS_LEN=8
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/Qwen2.5-1.5B-Instruct/gsm8k/weaver-grpo/pn=1_pl=8_in=0_il=8"
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/qwen2_5_gsm8k_sft.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="gsm8k"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=3
+PROMPT_LATENTS_LEN=8
+INFERENCE_LATENTS_LEN=8
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/Qwen2.5-1.5B-Instruct/gsm8k/weaver-sft/pn=1_pl=8_in=3_il=8"
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/qwen2_5_kodcode_grpo.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="kodcode"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=8
+INFERENCE_LATENTS_LEN=8
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/Qwen2.5-1.5B-Instruct/kodcode/weaver-grpo/pn=1_pl=8_in=0_il=8"
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/qwen2_5_kodcode_sft.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="kodcode"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=5
+PROMPT_LATENTS_LEN=4
+INFERENCE_LATENTS_LEN=4
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/Qwen2.5-1.5B-Instruct/kodcode/weaver-sft/pn=1_pl=4_in=5_il=4"
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/qwen2_5_triviaqa.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="triviaqa"
+
+MAX_PROMPT_AUG_NUM=8
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=8
+INFERENCE_LATENTS_LEN=8
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/Qwen2.5-1.5B-Instruct/triviaqa/weaver-sft/pn=8_pl=8_in=0_il=8"
+
+# evaluate
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/smollm_kodcode.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="HuggingFaceTB/SmolLM3-3B"
+WEAVER_MODEL="HuggingFaceTB/SmolLM3-3B"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="kodcode"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=5
+PROMPT_LATENTS_LEN=4
+INFERENCE_LATENTS_LEN=4
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/SmolLM3-3B/kodcode/weaver-sft/pn=1_pl=4_in=5_il=4"
+
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/eval/smollm_triviaqa.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+export DEBUG_MODE=true  
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29508
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="HuggingFaceTB/SmolLM3-3B"
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_ACTIVE=False
+
+DATASET_NAME="triviaqa"
+
+MAX_PROMPT_AUG_NUM=8
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=4
+INFERENCE_LATENTS_LEN=4
+
+BATCH_SIZE=4
+
+LOAD_MODEL_PATH="MemGen/SmolLM3-3B/triviaqa/weaver-sft/pn=8_pl=4_in=0_il=4"
+
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active ${TRIGGER_ACTIVE} \
+    run.mode evaluate \
+    run.interaction.batch_size ${BATCH_SIZE} \
+    run.interaction.temperature 0.0 \
+    run.interaction.max_response_length 1024 \

MemGen-main/scripts/train/qwen2_5_gsm8k_grpo.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+export DEBUG_MODE=true
+export LOG_PATH="./debug_log_2b.txt"
+export CUDA_VISIBLE_DEVICES=0
+export MAIN_PROCESS_PORT=29507
+
+# 自动计算 GPU 数量
+NUM_GPUS=$(echo $CUDA_VISIBLE_DEVICES | tr ',' '\n' | wc -l)
+echo "Using $NUM_GPUS GPU(s): CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
+export NCCL_DEBUG=INFO
+export NCCL_IB_DISABLE=1
+export NCCL_P2P_DISABLE=1
+export NCCL_ASYNC_DISABLE=1
+
+REASONER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"   
+WEAVER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+TRIGGER_MODEL="Qwen/Qwen2.5-1.5B-Instruct"
+
+DATASET_NAME="gsm8k"
+
+TRAIN_METHOD="grpo"
+
+MAX_PROMPT_AUG_NUM=1
+MAX_INFERENCE_AUG_NUM=0
+PROMPT_LATENTS_LEN=8
+INFERENCE_LATENTS_LEN=8
+
+BATCH_SIZE=1
+
+LOAD_MODEL_PATH=""
+
+
+# train
+python -m accelerate.commands.launch \
+    --config_file=configs/zero2.yaml \
+    --num_processes=${NUM_GPUS} \
+    main.py \
+    --cfg-path configs/latent_memory/${DATASET_NAME}.yaml \
+    --options \
+    model.model_name ${REASONER_MODEL} \
+    model.load_model_path ${LOAD_MODEL_PATH} \
+    model.max_prompt_aug_num ${MAX_PROMPT_AUG_NUM} \
+    model.max_inference_aug_num ${MAX_INFERENCE_AUG_NUM} \
+    model.weaver.model_name ${WEAVER_MODEL} \
+    model.weaver.prompt_latents_len ${PROMPT_LATENTS_LEN} \
+    model.weaver.inference_latents_len ${INFERENCE_LATENTS_LEN} \
+    model.trigger.model_name ${TRIGGER_MODEL} \
+    model.trigger.active False \
+    datasets.mode ${TRAIN_METHOD} \
+    run.mode train \
+    run.train_weaver True \
+    run.train_trigger False \
+    run.train_weaver_method ${TRAIN_METHOD} \
+    run.weaver.sft.per_device_train_batch_size ${BATCH_SIZE} \
+    run.weaver.sft.per_device_train_batch_size ${BATCH_SIZE} \
+    run.weaver.sft.bf16 True \
+    run.weaver.sft.gradient_accumulation_steps 1 \