Upload dataset

.gitattributes

@@ -57,3 +57,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+checkpoints/archer_Llama3-8B-I_strategic/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+checkpoints/archer_Llama3-8B-I_word/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250914_072202-c40vakf9/run-c40vakf9.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250914_191149-a5wf2wi9/run-a5wf2wi9.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250915_014504-agz3jw75/run-agz3jw75.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250915_111603-tnh8ytpw/run-tnh8ytpw.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250915_170938-mlb6ufl5/run-mlb6ufl5.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250915_234149-solrky9k/run-solrky9k.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20250916_001517-sdm2bc8f/run-sdm2bc8f.wandb filter=lfs diff=lfs merge=lfs -text

.vscode/launch.json

@@ -0,0 +1,61 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "OfflineArcher RSA Training",
+            "type": "python",
+            "request": "launch",
+            "python": "/home/jiashuo/anaconda3/envs/archer/bin/python",
+            "program": "${workspaceFolder}/main.py",
+            "args": [
+                "fit",
+                "--data=WordTaboo",
+                "--data.batch_size=2",
+                "--data.n_traj_eval=4",
+                "--data.base_model=Qwen3-14B",
+                "--model=OfflineArcher",
+                "--model.optimize_critic=True",
+                "--model.actor_lr=1e-5",
+                "--model.critic_lr=1e-5",
+                "--model.discount_factor=0.99",
+                "--model.tau=0.05",
+                "--model.critic_expectile=0.9",
+                "--model.inv_temp=1.0",
+                "--model.accumulate_grad_batches=16",
+                "--model.model_name_or_path=/home/jiashuo/codes/ForesightOptim/checkpoints/im_Qwen3-14B_rsa/merged_model",
+                "--trainer.fast_dev_run=False",
+                "--trainer.max_epoch=1",
+                "--trainer.logger=WandbLogger",
+                "--trainer.logger.init_args.project=RSAGame-Official",
+                "--trainer.default_root_dir=checkpoints/archer_Qwen3-14B_rsa",
+                "--trainer.logger.init_args.name=Test-AC-critic_expectile_0.9-inv_temp_1.0",
+                "--trainer.strategy=deepspeed_stage_3",
+                "--trainer.devices=8",
+                "--trainer.accelerator=gpu",
+                "--trainer.precision=bf16",
+                "--trainer.limit_val_batches=0",
+                "--trainer.val_check_interval=null",
+                "--trainer.enable_model_summary=false"
+            ],
+            "env": {
+                "PYTORCH_CUDA_ALLOC_CONF": "expandable_segments:True",
+                "ACCELERATE_USE_DEEPSPEED": "true",
+                "MASTER_PORT": "29500",
+                "TMPDIR": "$HOME/tmp",
+                "NCCL_P2P_DISABLE": "1",
+                "CUDA_LAUNCH_BLOCKING": "1",
+                "CUDA_DEVICE_MAX_CONNECTIONS": "1",
+                "PYTHONUNBUFFERED": "1",
+                "NCCL_DEBUG": "INFO",
+                "NCCL_DEBUG_SUBSYS": "INIT,ENV"
+            },
+            "deepSpeed": {
+                "enable": true,
+                "configPath": "${env:HOME}/codes/ForesightOptim/configs/deepspeed_zero3.yaml"
+            },
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

Algorithms.py

@@ -0,0 +1,755 @@
+import lightning as L
+from lightning.pytorch.utilities import rank_zero_only
+import torch
+import os
+import gc
+torch.set_float32_matmul_precision("high")
+
+from SimulateOnEnv import batch_simulate_on_environment
+from lightning.pytorch.callbacks import Callback
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+from typing import Optional
+from peft import LoraConfig, TaskType, get_peft_model, PeftModel
+
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+def safe_load(path):
+    """安全加载权重，处理大小不匹配"""
+    result = {}
+    with safe_open(path, framework="pt") as f:
+        for key in f.keys():
+            try:
+                result[key] = f.get_tensor(key)
+            except Exception as e:
+                print(f"Error loading {key}: {str(e)}")
+    return result
+
+
+def set_special_tokens(model, tokenizer):
+    if tokenizer.pad_token is None and tokenizer.pad_token_id is None:
+        print_rank_0(f"[WARNING] the pad token of the tokenizer is None")
+        # We do not resize the vocab embedding, since it ruins the KL value with the ref_model
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+        tokenizer.pad_token = tokenizer.eos_token
+        # tokenizer.pad_token = tokenizer.decode(0)
+
+    model.config.pad_token_id = tokenizer.pad_token_id
+    model.config.bos_token_id = tokenizer.bos_token_id
+    model.config.eos_token_id = tokenizer.eos_token_id
+
+    return model, tokenizer
+
+def load_model_and_tokenizer(model_name_or_path, actor_checkpoint=None):
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name_or_path,
+        trust_remote_code=True,
+        use_cache=False,
+        torch_dtype=torch.bfloat16,
+        low_cpu_mem_usage=True,
+    )
+    
+    if hasattr(model, "ref_model"):
+        del model.ref_model
+    
+    lora_config = LoraConfig(
+        r=8,
+        lora_alpha=16,
+        target_modules=["q_proj", "v_proj"],
+        lora_dropout=0.05,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+    )
+    model = get_peft_model(model, lora_config) 
+    
+    if actor_checkpoint is not None:
+        weight_map = {}
+        with safe_open(actor_checkpoint, framework="pt") as f:
+            for key in f.keys():
+                new_key = key.replace("base_model.model.", "")
+                weight_map[new_key] = f.get_tensor(key)
+        
+        # 应用权重
+        for name, param in model.named_parameters():
+            for key, tensor in weight_map.items():
+                if key in name and param.shape == tensor.shape:
+                    param.data.copy_(tensor)
+                    print(f"加载权重: {name} <- {key}")
+                    break
+        
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_name_or_path,
+        padding_side="left",  # for batch decode
+        truncation_side="left",
+        model_max_length=1024,
+        trust_remote_code=True,
+    )
+
+    model.gradient_checkpointing_enable()
+    model, tokenizer = set_special_tokens(model, tokenizer)
+    
+    return model, tokenizer
+
+
+class ActorModel(torch.nn.Module):
+    def __init__(self, get_device, model_name_or_path, actor_checkpoint=None):
+        super().__init__()
+        self.get_device = get_device
+        self.model, self.tokenizer = load_model_and_tokenizer(model_name_or_path, actor_checkpoint)
+
+    def forward(self, observation, do_sample=True):
+        obs_ids = self.tokenizer(
+            observation,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=512,
+        ).to(self.model.device)
+        obs_embeds = self.model.get_input_embeddings()(obs_ids["input_ids"])
+        outputs = self.model.generate(
+            inputs_embeds=obs_embeds,
+            attention_mask=obs_ids["attention_mask"],
+            max_new_tokens=32,
+            do_sample=do_sample,
+            pad_token_id=self.tokenizer.eos_token_id,
+        )
+        action = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        return action
+
+    def behavioral_cloning_loss(self, observation, action, **kwargs):
+        logsum_probs = self.get_logsum_prob(
+            observation, action
+        )  # this line has been refactored and not tested
+        loss = -logsum_probs.mean()
+        return loss, {"behavioral_cloning/loss": loss.detach()}
+
+    def get_logsum_prob(self, observation, action_from_dataloader, **kwargs):
+        action = [a + self.tokenizer.eos_token for a in action_from_dataloader]
+        alltext = [obs + a for obs, a in zip(observation, action)]
+        generated_probabilities = self.to_tokens_and_logprobs(alltext)
+        assert (
+            len(generated_probabilities)
+            == len(alltext)
+            == len(observation)
+            == len(action)
+        )
+        mask = torch.zeros_like(generated_probabilities.detach(), dtype=torch.bool)
+
+        for i, (obs, act, text) in enumerate(zip(observation, action, alltext)):
+            assert text == obs + act
+            act_ids = self.tokenizer(act, return_tensors="pt", padding=True)
+            txt_ids = self.tokenizer(text, return_tensors="pt", padding=True)
+            n_token_act = len(
+                act_ids["input_ids"][0]
+            )  # [0] because the batch is one inside the foor loop
+            n_token_txt = len(txt_ids["input_ids"][0])
+            mask[i, n_token_txt - n_token_act - 1 : n_token_txt - 1] = (
+                True  # the -1 shift is due to the the generated probabilities being shifted
+            )
+
+        generated_probabilities = torch.where(mask, generated_probabilities, 1.0)
+        log_probs = torch.where(
+            mask, torch.log(generated_probabilities), 0.0
+        )  # must be separate from the line above for numerical stability (cannot take log(0.0))
+        logsum_probs = torch.sum(log_probs, dim=1)
+        del act_ids, txt_ids, log_probs, generated_probabilities
+        return logsum_probs
+
+    def to_tokens_and_logprobs(self, input_texts):
+        input_ids = self.tokenizer(
+            input_texts, padding=True, truncation=True, return_tensors="pt"
+        ).input_ids.to(self.get_device())
+        outputs = self.model(input_ids)
+        probs = torch.softmax(outputs.logits, dim=-1)
+
+        # collect the probability of the generated token -- probability at index 0 corresponds to the token at index 1
+        probs = probs[:, :-1, :]
+        input_ids = input_ids[:, 1:]
+        gen_probs = torch.gather(probs, 2, input_ids[:, :, None]).squeeze(-1)
+        del outputs, probs
+        torch.cuda.empty_cache()
+        gc.collect()
+        torch.cuda.memory._set_allocator_settings('max_split_size_mb:32')
+        return gen_probs
+
+
+class RobertaCritic(torch.nn.Module):
+    def __init__(
+        self,
+        get_device,
+        discount_factor: float,
+        tau: float,
+        expectile: float,
+        from_checkpoint=None,
+    ):
+        super().__init__()
+
+        self.get_device = get_device
+        self.discount_factor = discount_factor
+        self.tau = tau
+        self.expectile = expectile
+
+        ### Define the Critic
+        from ArcherCritic import ArcherDoubleCritic
+
+        self.critic = ArcherDoubleCritic(in_dim=768, out_dim=1)
+        self.target_critic = ArcherDoubleCritic(in_dim=768, out_dim=1)
+        self.soft_update_target_critic(1)
+
+        if from_checkpoint is not None:
+            checkpoint = torch.load(from_checkpoint, map_location=torch.device("cpu"))
+            weights = {
+                k.removeprefix("critic."): v
+                for k, v in checkpoint["state_dict"].items()
+                if k.startswith("critic.")
+            }
+            self.load_state_dict(weights)
+            print(
+                "I have initialized the critic from the checkpoint: ", from_checkpoint
+            )
+
+        ### Miscellaneus Shortcuts
+        self.softmax = torch.nn.Softmax(dim=-1)
+        self.td_criterion = torch.nn.MSELoss()
+        self.expectile_criterion = lambda diff: self.loss_value_diff(
+            diff=diff, expectile=self.expectile
+        )
+
+    def get_q(self, observation, action, detach_model=False):
+        return self.critic.get_q(observation, action, detach_model=detach_model)
+
+    def get_v(self, inputs, detach_model=False):
+        return self.critic.get_v(inputs, detach_model=detach_model)
+
+    def get_target_v(self, inputs, detach_model=False):
+        return self.target_critic.get_v(inputs, detach_model=detach_model)
+
+    def get_target_q(self, observation, action, detach_model=False):
+        return self.target_critic.get_q(observation, action, detach_model=detach_model)
+
+    def get_advantages(self, observation, action):
+        q1, q2 = self.get_q(observation, action)
+        v1, v2 = self.get_v(observation)
+        q = torch.minimum(q1, q2)
+        v = torch.minimum(v1, v2)
+        advantages = q - v
+        return advantages
+
+    def argmax_advantage(self, observation, get_available_actions):
+        argmax_actions = []
+        for obs in observation:
+            available_actions = get_available_actions(obs)
+            advantages = torch.as_tensor(
+                [self.get_advantages([obs], [action]) for action in available_actions]
+            )
+            action = available_actions[torch.argmax(advantages)]
+            argmax_actions.append(action)
+        return argmax_actions
+
+    def soft_update_target_critic(self, tau=None):
+        if tau == None:
+            tau = self.tau
+        for target_param, param in zip(
+            self.target_critic.parameters(), self.critic.parameters()
+        ):
+            target_param.data.copy_(target_param.data * (1.0 - tau) + param.data * tau)
+
+    def iql_loss(self, observation, action, reward, next_observation, done, **kwargs):
+        ### Fitting the Q function
+        q1, q2 = self.get_q(observation, action, detach_model=False)
+        q1 = q1.flatten()
+        q2 = q2.flatten()
+
+        reward = torch.Tensor(reward)  # .to(self.agent.device)
+        done = torch.Tensor(done)  # .to(self.agent.device)
+
+        with torch.no_grad():
+            target_v1, target_v2 = self.get_target_v(next_observation)
+
+            target_v1 = (
+                reward
+                + torch.logical_not(done) * target_v1.flatten() * self.discount_factor
+            )
+            target_v2 = (
+                reward
+                + torch.logical_not(done) * target_v2.flatten() * self.discount_factor
+            )
+
+        q1_loss = self.td_criterion(q1, target_v1)
+        q2_loss = self.td_criterion(q2, target_v2)
+
+        ### Fitting the value function
+        with torch.no_grad():
+            target_q1, target_q2 = self.get_target_q(
+                observation, action, detach_model=False
+            )
+        target_q1 = target_q1.flatten()
+        target_q2 = target_q2.flatten()
+
+        v1, v2 = self.get_v(observation, detach_model=False)
+        v1 = v1.flatten()
+        v2 = v2.flatten()
+
+        v1_loss = self.expectile_criterion(diff=target_q1.detach() - v1)
+        v2_loss = self.expectile_criterion(diff=target_q2.detach() - v2)
+
+        loss = q1_loss + q2_loss + v1_loss + v2_loss
+
+        ### Log and print what's happening
+        log = self.get_log(
+            q1=q1,
+            q2=q2,
+            v1=v1,
+            v2=v2,
+            q1_loss=q1_loss,
+            q2_loss=q2_loss,
+            v1_loss=v1_loss,
+            v2_loss=v2_loss,
+            target_q1=target_q1,
+            target_q2=target_q2,
+        )
+        return loss, log
+
+    def loss_value_diff(self, diff, expectile):
+        """Loss function for iql expectile value difference."""
+        weight = torch.where(diff > 0, expectile, (1 - expectile))
+        return (weight * (diff**2)).mean()
+
+    def get_log(
+        self, q1, q2, v1, v2, q1_loss, q2_loss, v1_loss, v2_loss, target_q1, target_q2
+    ):
+        return {
+            "critic/q1.loss": q1_loss.detach(),
+            "critic/q2.loss": q2_loss.detach(),
+            "critic/v1.loss": v1_loss.detach(),
+            "critic/v2.loss": v2_loss.detach(),
+            "critic/q1.mean": torch.mean(q1).detach(),
+            "critic/q1.min": torch.min(q1).detach(),
+            "critic/q1.max": torch.max(q1).detach(),
+            "critic/q2.mean": torch.mean(q2).detach(),
+            "critic/q2.max": torch.max(q2).detach(),
+            "critic/q2.min": torch.min(q2).detach(),
+            "critic/v1.mean": torch.mean(v1).detach(),
+            "critic/v1.min": torch.min(v1).detach(),
+            "critic/v1.max": torch.max(v1).detach(),
+            "critic/v2.mean": torch.mean(v2).detach(),
+            "critic/v2.max": torch.max(v2).detach(),
+            "critic/v2.min": torch.min(v2).detach(),
+            "critic/target_q1.mean": torch.mean(target_q1).detach(),
+            "critic/target_q1.min": torch.min(target_q1).detach(),
+            "critic/target_q1.max": torch.max(target_q1).detach(),
+            "critic/target_q2.mean": torch.mean(target_q2).detach(),
+            "critic/target_q2.max": torch.max(target_q2).detach(),
+            "critic/target_q2.min": torch.min(target_q2).detach(),
+        }
+
+
+class Agent(L.LightningModule):
+    def validation_step(self, batch, batch_idx):
+
+        # Perform evaluation on environment with stochastic policy
+        return None
+        eval_dataset = batch_simulate_on_environment(
+            policy=lambda obs: self.forward(obs), env=None
+        )
+        self.log(
+            "eval/avg_return", eval_dataset.mean_trajectory_return(), sync_dist=True
+        )
+        self.log(
+            "eval/std_return", eval_dataset.std_trajectory_return(), sync_dist=True
+        )
+
+        # Perform evaluation on environment with deterministic policy
+        deterministic_eval_dataset = batch_simulate_on_environment(
+            policy=lambda obs: self.forward(obs, do_sample=False),
+            env=None,
+        )
+        self.log(
+            "eval/avg_return_deterministic",
+            deterministic_eval_dataset.mean_trajectory_return(),
+            sync_dist=True,
+        )
+        self.log(
+            "eval/std_return_deterministic",
+            deterministic_eval_dataset.std_trajectory_return(),
+            sync_dist=True,
+        )
+
+        return eval_dataset.mean_trajectory_return()
+
+
+class BehaviouralCloning(Agent):
+    def __init__(self, lr: float):
+        super().__init__()  # Initialize LLM base class
+        self.save_hyperparameters()
+
+        ### Config
+        self.lr = lr
+
+        ### Initialization
+        self.agent = ActorModel(get_device=lambda: self.device)
+
+    def forward(self, observation, **kwargs):
+        return self.agent.forward(observation, **kwargs)
+
+    def training_step(self, batch, batch_idx):
+        loss, log = self.agent.behavioral_cloning_loss(**batch)
+        self.log_dict(log, sync_dist=True)
+        return loss
+
+    def configure_optimizers(self):
+        from torch.optim import Adam
+        
+        # 收集所有需要优化的���数
+        optimizer_params = [
+            {"params": self.actor.model.parameters(), "lr": self.actor_lr},
+        ]
+        
+        # 如果需要优化critic，添加其参数
+        if self.optimize_critic:
+            optimizer_params.append({
+                "params": self.critic.critic.parameters(), 
+                "lr": self.critic_lr
+            })
+        
+        # 创建单个优化器
+        optimizer = Adam(optimizer_params)
+        
+        return optimizer
+
+
+class FilteredBehaviouralCloning(BehaviouralCloning):
+    def __init__(self, lr: float, filter: float):
+        super().__init__(lr)
+
+        self.filter = filter
+
+    def configure_callbacks(self):
+        return FilterDataset(filter=self.filter)
+
+
+class FilterDataset(Callback):
+    def __init__(self, filter: float):
+        self.filter = filter
+
+    def on_fit_start(self, trainer, algorithm):
+        print("*** Filtering Dataset ***")
+        dataset = trainer.datamodule.dataset
+        print("Statistics of Input Dataset")
+        print("Number of Trajectories:", dataset.nTrajectories())
+        print("Number of Trajectories:", len(dataset))
+        dataset.keep_top_fraction_of_trajectories(fraction=self.filter)
+        trainer.datamodule.dataset = dataset
+        print("Statistics of Filtered Dataset")
+        print("Number of Trajectories:", dataset.nTrajectories())
+        print("Number of Trajectories:", len(dataset))
+
+
+class ActorCritic(Agent):
+    def __init__(
+        self,
+        model_name_or_path: str,
+        actor_lr: float,
+        critic_lr: float,
+        tau: float,
+        accumulate_grad_batches: int,
+        discount_factor: float,
+        critic_expectile: float,
+        optimize_critic: bool,
+        actor_checkpoint=None,
+        critic_checkpoint=None,
+        **kwargs
+    ):
+        super().__init__()  # Initialize LLM base class
+        self.example_input_array = (torch.zeros(1, 1, dtype=torch.long),)
+        self.save_hyperparameters()
+        ### Config
+        self.actor_lr = actor_lr
+        self.critic_lr = critic_lr
+        self.discount_factor = discount_factor
+        self.tau = tau
+
+        ### Manual Gradient Accumulation
+        self.accumulate_grad_batches = accumulate_grad_batches
+        self.automatic_optimization = False
+
+        ### Initialization
+        self.actor = ActorModel(
+            get_device=lambda: self.device, model_name_or_path=model_name_or_path, actor_checkpoint=actor_checkpoint
+        )
+        self.critic = RobertaCritic(
+            get_device=lambda: self.device,
+            discount_factor=discount_factor,
+            tau=tau,
+            expectile=critic_expectile,
+            from_checkpoint=critic_checkpoint,
+        )
+        
+        self.actor_current_backward_step = 0
+        self.critic_current_backward_step = 0
+        self.critic_warmup_gradient_steps = 0
+
+        self.optimize_actor = lambda: (
+            True
+            if self.critic_current_backward_step // self.accumulate_grad_batches
+            >= self.critic_warmup_gradient_steps
+            else False
+        )
+        self.optimize_critic = lambda: optimize_critic
+
+    def forward(self, observation, **kwargs):
+        action = self.actor.forward(observation, **kwargs)
+        return action
+    
+    def training_step(self, batch, batch_idx):
+        # if batch_idx == 3:
+        #     return
+                    
+        optimizer = self.optimizers()
+        mem = torch.cuda.memory_allocated() / torch.cuda.get_device_properties(0).total_memory
+        if mem > 0.8:
+            gc.collect()
+            torch.cuda.empty_cache()
+
+        if self.optimize_critic():
+            # scale losses by 1/N (for N batches of gradient accumulation)
+            critic_loss, critic_log = self.critic_loss(batch)
+            critic_loss /= self.accumulate_grad_batches
+            self.manual_backward(critic_loss)
+            self.critic_current_backward_step += 1
+            self.log_dict(critic_log, sync_dist=True)
+
+            # accumulate gradients of N batches
+            if self.critic_current_backward_step % self.accumulate_grad_batches == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                self.critic.soft_update_target_critic(self.tau)
+            
+
+        if self.optimize_actor():
+            # scale losses by 1/N (for N batches of gradient accumulation)
+            
+            actor_loss, actor_log = self.actor_loss(batch)
+            actor_loss /= self.accumulate_grad_batches
+            self.manual_backward(actor_loss)
+            self.actor_current_backward_step += 1
+            self.log_dict(actor_log, sync_dist=True)
+
+            # accumulate gradients of N batches
+            if self.actor_current_backward_step % self.accumulate_grad_batches == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+
+    def get_actor_log(self, loss, advantages, log_prob):
+        return {
+            "actor/loss": loss.detach(),
+            "actor/advantages.mean": advantages.detach().mean(),
+            "actor/advantages.max": torch.max(advantages.detach()),
+            "actor/advantages.min": torch.min(advantages.detach()),
+            "actor/log_prob.mean": torch.mean(log_prob.detach()),
+            "actor/log_prob.max": torch.max(log_prob.detach()),
+            "actor/log_prob.min": torch.min(log_prob.detach()),
+        }
+
+    def configure_optimizers(self):
+        from torch.optim import Adam
+        
+        optimizer_params = []
+        
+        if hasattr(self, 'actor') and hasattr(self.actor, 'parameters'):
+            optimizer_params.append({
+                "params": self.actor.parameters(), 
+                "lr": self.actor_lr
+            })
+        
+        if self.optimize_critic and hasattr(self, 'critic') and hasattr(self.critic, 'parameters'):
+            optimizer_params.append({
+                "params": self.critic.parameters(), 
+                "lr": self.critic_lr
+            })
+        
+        if not optimizer_params:
+            return None
+        
+        optimizer = Adam(optimizer_params)
+        return optimizer
+
+
+class OfflineArcher(ActorCritic):
+    def __init__(
+        self,
+        model_name_or_path: str,
+        inv_temp: float,
+        actor_lr: float,
+        critic_lr: float,
+        tau: float,
+        accumulate_grad_batches: int,
+        discount_factor: float,
+        critic_expectile: float,
+        optimize_critic: bool,
+        actor_checkpoint: Optional[str] = None,
+        critic_checkpoint: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            model_name_or_path=model_name_or_path,
+            actor_lr=actor_lr,
+            critic_lr=critic_lr,
+            tau=tau,
+            accumulate_grad_batches=accumulate_grad_batches,
+            discount_factor=discount_factor,
+            critic_expectile=critic_expectile,
+            optimize_critic=optimize_critic,
+            actor_checkpoint=actor_checkpoint,
+            critic_checkpoint=critic_checkpoint,
+            **kwargs
+        )
+
+        self.inv_temp = inv_temp
+
+        self.actor_loss = lambda batch: self.awr_loss(**batch)
+        self.critic_loss = lambda batch: self.critic.iql_loss(**batch)
+
+    def awr_loss(self, observation, action, **kwargs):
+        log_prob = self.actor.get_logsum_prob(observation, action)
+        with torch.no_grad():
+            advantages = self.critic.get_advantages(observation, action)
+
+        advantages = advantages.flatten()
+        log_prob = log_prob.flatten()
+        factor = torch.exp(self.inv_temp * advantages)
+        loss_batch = -factor * log_prob
+        loss = loss_batch.mean()
+
+        # ### Log and print what's happening
+        log = self.get_actor_log(loss=loss, advantages=advantages, log_prob=log_prob)
+        log = {
+            **log,
+            **{
+                "actor/factor.mean": factor.detach().mean(),
+                "actor/factor.max": torch.max(factor.detach()),
+                "actor/factor.min": torch.min(factor.detach()),
+            },
+        }
+
+        return loss, log
+    
+    def configure_optimizers(self):
+        # 直接调用基类方法
+        return super().configure_optimizers()
+    
+    @rank_zero_only
+    def on_save_checkpoint(self, checkpoint):
+        """保存 LoRA 适配器权重"""
+        super().on_save_checkpoint(checkpoint)
+        
+        save_dir = self.trainer.default_root_dir
+        os.makedirs(save_dir, exist_ok=True)
+        
+        # 保存 LoRA 适配器
+        if hasattr(self.actor.model, "save_pretrained"):
+            self.actor.model.save_pretrained(save_dir)
+        
+        # 保存 tokenizer
+        if hasattr(self.actor, "tokenizer"):
+            self.actor.tokenizer.save_pretrained(save_dir)
+        
+        print(f"✅ LoRA adapter saved to: {save_dir}")
+        self.merge_and_save_lora(os.path.join(save_dir, "merged_model"))
+        
+    def merge_and_save_lora(self, save_dir):
+        """
+        Merge the LoRA adapter weights into the base model and save the merged model and tokenizer.
+        """
+        # Only proceed if the actor model has the correct method
+        try:
+            # 确保模型在CPU上且处于eval模式
+            original_device = next(self.actor.model.parameters()).device
+            self.actor.model.to('cpu')
+            self.actor.model.eval()
+            
+            if hasattr(self.actor.model, "merge_and_unload"):
+                # 执行合并
+                merged_model = self.actor.model.merge_and_unload()
+                
+                # 检查合并结果
+                from peft import PeftModel
+                if isinstance(merged_model, PeftModel):
+                    print(">>> [Warning] Still a PeftModel after merge. Using base_model.model...")
+                    merged_model = merged_model.base_model.model
+                
+                # 保存合并后的模型
+                merged_model.save_pretrained(os.path.join(save_dir, "merged_model"))
+                print(f"✅ Merged model saved to: {os.path.join(save_dir, 'merged_model')}")
+            else:
+                print("❌ merge_and_unload method not found in actor.model. Cannot merge LoRA weights.")
+        except Exception as e:
+            print(f"❌ Error merging LoRA weights: {e}")
+            import traceback
+            traceback.print_exc()
+        finally:
+            # 恢复原始设备
+            self.actor.model.to(original_device)
+
+
+class IQLKL(ActorCritic):
+    def __init__(self, kl_coeff: float, reference_actor_path, **kwargs):
+        super().__init__(**kwargs)
+
+        self.kl_coeff = kl_coeff
+        self.reference_actor = ActorModel(
+            get_device=lambda: self.device, from_checkpoint=reference_actor_path
+        )
+
+        self.actor_loss = lambda batch: self.advantage_kl_loss(**batch)
+        self.critic_loss = lambda batch: self.critic.iql_loss(**batch)
+
+    def advantage_kl_loss(self, observation, **kwargs):
+        reinforce_loss, generated_output = self.reinforce_loss(observation=observation)
+        with torch.no_grad():
+            reference_log_prob = self.reference_actor.get_logsum_prob(
+                observation, generated_output["action"]
+            )
+
+        ratio = generated_output["log_prob"] - reference_log_prob
+        kl_loss = (ratio.detach() + 1.0) * generated_output["log_prob"]
+        loss = (1 - self.kl_coeff) * reinforce_loss + self.kl_coeff * kl_loss
+        log = generated_output["log"]
+        log = {
+            **log,
+            "reference_log_prob.mean": reference_log_prob.mean(),
+            "reference_log_prob.max": reference_log_prob.max(),
+            "reference_log_prob.min": reference_log_prob.min(),
+        }
+        log = {
+            **log,
+            "kl_loss.mean": kl_loss.mean(),
+            "kl_loss.max": kl_loss.max(),
+            "kl_loss.min": kl_loss.min(),
+        }
+        log = {**log, "actor_loss.mean": loss.mean(), "ratio": ratio.mean()}
+
+        return loss.mean(), log
+
+    def reinforce_loss(self, observation, **kwargs):
+        ### Reinforce Loss
+        action = self.actor.forward(observation)
+        log_prob = self.actor.get_logsum_prob(observation, action)
+
+        with torch.no_grad():
+            advantages = self.critic.get_advantages(observation, action)
+
+        loss = -advantages.flatten() * log_prob
+
+        ### Logging
+        log = self.get_actor_log(
+            loss=torch.mean(loss.detach()), advantages=advantages, log_prob=log_prob
+        )
+        # self.log_dict(log)
+        return loss, {
+            "log_prob": log_prob,
+            "advantages": advantages,
+            "action": action,
+            "log": log,
+        }

ArcherCritic.py

@@ -0,0 +1,161 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoTokenizer, RobertaModel
+import torch.nn as nn
+from transformers import RobertaTokenizer, RobertaModel
+import logging
+# A logger for this file
+log = logging.getLogger(__name__)
+
+class ArcherDoubleCritic(torch.nn.Module):
+    def __init__(self, in_dim, out_dim):
+        super(ArcherDoubleCritic, self).__init__()
+        self.base_lm = RobertaModel.from_pretrained('roberta-base', torch_dtype=torch.float16)
+
+        ################
+        print("*** Master Warning - Are these used? *** ")
+        # self.base_lm.pooler.dense.weight = None
+        # self.base_lm.pooler.dense.bias   = None
+        ###############
+        self.base_tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
+        self.base_tokenizer.truncation_side = 'left'
+        self.critic1 = nn.Sequential(nn.Linear(in_dim*2, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.critic2 = nn.Sequential(nn.Linear(in_dim*2, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.v_critic1 = nn.Sequential(nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.v_critic2 = nn.Sequential(nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+    
+    def get_q(self, observation, action, detach_model=False):
+        state_actions = [o + a for o,a in zip(observation, action)]
+        obs_ids = self.base_tokenizer(observation, padding = True, return_tensors='pt', truncation=True, max_length=512).to(self.base_lm.device)
+        if detach_model:
+            with torch.no_grad():
+                lm_states = self.base_lm(**obs_ids).last_hidden_state[:,0]
+        else:
+            lm_states = self.base_lm(**obs_ids).last_hidden_state[:,0]
+        action_ids = self.base_tokenizer(action, padding = True, return_tensors='pt', truncation=True, max_length=512).to(self.base_lm.device)
+        if detach_model:
+            with torch.no_grad():
+                action_states = self.base_lm(**action_ids).last_hidden_state[:,0]
+        else:
+            action_states = self.base_lm(**action_ids).last_hidden_state[:,0]
+        lm_states = torch.cat([lm_states, action_states], dim = 1)
+        return self.critic1(lm_states), self.critic2(lm_states)
+
+    def get_v(self, observation,detach_model=False):
+        obs_ids = self.base_tokenizer(observation, padding = True, return_tensors='pt', truncation=True, max_length=512).to(self.base_lm.device)
+        if detach_model:
+            with torch.no_grad():
+                lm_states = self.base_lm(**obs_ids).last_hidden_state[:,0]
+        else:
+            lm_states = self.base_lm(**obs_ids).last_hidden_state[:,0]
+        # print(action.size())
+        return self.v_critic1(lm_states), self.v_critic2(lm_states)
+
+
+class ArcherCritic(torch.nn.Module):
+    def __init__(self, in_dim=768, out_dim=4096, dropout = 0.5):
+        super(ArcherCritic, self).__init__()
+        self.model = AutoModelForCausalLM.from_pretrained('gpt2')
+        self.critic = ArcherDoubleCritic(in_dim = 768, out_dim = 1)  
+        self.target_critic = ArcherDoubleCritic(in_dim = 768, out_dim = 1) 
+        self.soft_update_target_critic(1)
+        self.tokenizer = AutoTokenizer.from_pretrained('gpt2', trust_remote_code=True)
+        self.tokenizer.truncation_side = 'left'
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
+        # self.device = device
+        self.dropout = torch.nn.Dropout(p=dropout)
+        self.softmax = torch.nn.Softmax(dim= -1)
+
+    def get_action(self, observation):
+        obs_ids = self.tokenizer(observation, return_tensors='pt', padding=True, max_length=512).to(self.model.device)
+        obs_embeds = self.model.get_input_embeddings()(obs_ids["input_ids"])
+        outputs = self.model.generate(inputs_embeds=obs_embeds, attention_mask=obs_ids['attention_mask'],\
+                                       max_new_tokens=32, do_sample=True, \
+                                       pad_token_id = self.tokenizer.eos_token_id)#.cpu()
+        raw_action = self.tokenizer.batch_decode(outputs, skip_special_tokens  = True)
+        return raw_action
+
+    def get_q(self, observation, action, detach_model=False):
+        return self.critic.get_q(observation, action, detach_model = detach_model)
+
+    def get_v(self, inputs, detach_model=False):
+        return self.critic.get_v(inputs, detach_model = detach_model)
+    
+    def get_target_q(self, observation, action, detach_model=False):
+        return self.target_critic.get_q(observation, action, detach_model = detach_model)
+
+    def get_log_prob(self, observation, action):
+        obs_ids = self.tokenizer(observation, return_tensors='pt', padding=True, max_length=512).to(self.model.device)
+        action_ids = self.tokenizer(action, return_tensors='pt', padding=True, max_length=512).to(self.model.device)
+        action_embeds = self.model.get_input_embeddings()(action_ids["input_ids"]).detach()
+        obs_embeds = self.model.get_input_embeddings()(obs_ids["input_ids"]).detach()
+        input_embeds = torch.cat([obs_embeds, action_embeds], dim = 1)
+        attention_mask = torch.cat([obs_ids["attention_mask"], action_ids["attention_mask"]],\
+                                dim = 1)
+        outputs = self.model(inputs_embeds = input_embeds, attention_mask = attention_mask)
+        prediction_probs = self.softmax(outputs.logits)
+        selected_prediction_probs = torch.take_along_dim(prediction_probs[:, obs_ids["attention_mask"].size(1)-1:-1],\
+                                                 action_ids["input_ids"].unsqueeze(2), dim=2).squeeze(2)
+        logsum_probs = torch.sum(torch.log(selected_prediction_probs)*action_ids["attention_mask"], dim = 1)
+        return logsum_probs
+    
+    def soft_update_target_critic(self, tau):
+        # for target_critic, critic in zip(self.target_critics, self.critics):
+        for target_param, param in zip(
+                self.target_critic.parameters(), self.critic.parameters()
+            ):
+                target_param.data.copy_(
+                    target_param.data * (1.0 - tau) + param.data * tau
+                )
+
+class DoubleCritic(torch.nn.Module):
+    """
+    a double critic without base lm
+    """
+    def __init__(self, in_dim, out_dim):
+        super(DoubleCritic, self).__init__()
+        # self.device = device
+        self.critic1 = nn.Sequential(nn.Linear(in_dim*2, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.critic2 = nn.Sequential(nn.Linear(in_dim*2, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.v_critic1 = nn.Sequential(nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+        self.v_critic2 = nn.Sequential(nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, in_dim),\
+                                    nn.ReLU(),\
+                                    nn.Linear(in_dim, out_dim))#.to(device)
+    
+    def get_q(self, observation, action, detach_model=False):
+        lm_states = torch.cat([observation, action], dim = 1)
+        return self.critic1(lm_states), self.critic2(lm_states)
+
+    def get_v(self, observation,detach_model=False):
+        return self.v_critic1(observation), self.v_critic2(observation)

Dataset.py

@@ -0,0 +1,328 @@
+from torch.utils.data import Dataset
+import numpy as np
+import copy
+from torch.utils.data import Dataset
+
+class DummyDataset(Dataset):
+    def __init__(self, buffer):
+        self.buffer = buffer
+
+    def __len__(self):
+        return len(self.buffer)
+
+    def __getitem__(self, idx):
+        return self.buffer[idx]
+
+
+class Transition:
+    def __init__(self, observation, action, reward, next_observation, done, **kwargs):
+        self.observation       = observation
+        self.action            = action
+        self.reward            = np.single(reward)
+        self.next_observation  = next_observation
+
+        if isinstance(done, bool):
+            self.done          = done
+        elif done == 'False':
+            self.done          = False
+        elif done == 'True':
+            self.done          = True
+        else: 
+            raise ValueError
+        
+        # internal, to see how many times a certain transition was sampled
+        self.times_was_sampled = 0
+    def as_dict(self, as_string = False):
+        return {
+            "observation":      self.observation,
+            "action":           self.action,
+            "reward":           self.reward if as_string == False else str(self.reward),
+            "next_observation": self.next_observation,
+            "done":             self.done if as_string == False else str(self.done)
+        }
+    def __str__(self):
+        printout = '\n'
+        for key in self.as_dict():
+            printout += "\n" + key + ':'
+            printout += '\n' + str(self.as_dict()[key])
+        return printout
+
+class Trajectory:
+    def __init__(self):
+        self.transitions = []
+        self.info        = {}
+    def __len__(self):
+        return len(self.transitions)
+    def check_consistency(self):
+        assert(any([transition.done for transition in self.transitions[:-1]]) == False) # should not be done until the end
+        assert(self.transitions[-1].done == True )
+        for t in range(1,len(self.transitions)):
+            prior_transition   = self.transitions[t-1]
+            current_transition = self.transitions[t]
+            assert(prior_transition.next_observation == current_transition.observation)
+    def get_rewards(self):
+        return [transition.reward for transition in self.transitions]
+    def get_return(self):
+        return sum([transition.reward for transition in self.transitions])
+    def append(self, transition):
+        assert(self.transitions == [] or self.transitions[-1].done == False)
+        self.transitions.append(Transition(**transition))
+    def __str__(self):
+        printout = '\n*** Trajectory Begins *** \n'
+        printout += "\nTrajectory Length: " + str(len(self))
+        for idx, transition in enumerate(self.transitions):
+            printout += "\nTransition: " + str(idx)
+            printout += "\n" + transition.__str__()
+        if self.info != None:
+            printout += "\nFound Special Items"  
+            printout += str(self.info)
+        printout += '\n *** Trajectory Ends **** \n'
+        return printout
+
+class TrajectoryDataset(Dataset):
+    def __init__(self):
+        self.trajectories              = []
+        self.samples                   = [] # pointer list for fast sampling
+        self._last_oar                 = None # Last (observation, action, reward) for sequential addition
+    def __len__(self):
+        return len(self.samples)
+    def __getitem__(self, idx): 
+        self.samples[idx].times_was_sampled += 1
+        ### Must return a copy to avoid issues if further processing is done
+        return copy.deepcopy(self.samples[idx].as_dict())
+    def append_trajectory(self, trajectory: Trajectory):
+        trajectory.check_consistency()
+        assert(self.last_trajectory_reached_end())
+        for transition in trajectory.transitions:
+            self.append_sample_sequentially(copy.deepcopy(transition.as_dict()))
+        self.trajectories[-1].info = copy.deepcopy(trajectory.info)
+        self.trajectories[-1].check_consistency()
+    def append_observation_action_reward(self, observation, action, reward):
+        if self._last_oar != None:
+            self.append_sample_sequentially({"observation": self._last_oar["observation"],
+                                             "action": self._last_oar["action"],
+                                             "reward": self._last_oar["reward"],
+                                             "next_observation": observation,
+                                             "done": False })
+        self._last_oar = {"observation": observation,
+                          "action": action,
+                          "reward": reward}
+    def append_terminal_observation(self, observation, trajectory_info = None):
+        assert self._last_oar != None
+        self.append_sample_sequentially({"observation": self._last_oar["observation"],
+                                         "action": self._last_oar["action"],
+                                         "reward": self._last_oar["reward"],
+                                         "next_observation": observation,
+                                         "done": True })
+        self._last_oar = None
+        if trajectory_info != None:
+            self.trajectories[-1].info = trajectory_info
+        self.trajectories[-1].check_consistency()
+
+    def last_trajectory_reached_end(self):  
+        return (self.trajectories == [] or self.trajectories[-1].transitions[-1].done)
+         
+    def append_sample_sequentially(self, transition):
+        ### is the trajectory new?
+        if self.last_trajectory_reached_end():
+            self.trajectories.append(Trajectory())
+        self.trajectories[-1].transitions.append(Transition(**transition))
+        self.samples.append(self.trajectories[-1].transitions[-1])
+    def nTrajectories(self):
+        return len(self.trajectories)
+    def get_all_trajectory_returns(self):
+        return np.asarray([trajectory.get_return() for trajectory in self.trajectories])
+    def check_consistency(self):
+        assert (sum([len(trajectory) for trajectory in self.trajectories]) == len(self.samples))
+        for trajectory in self.trajectories:
+            trajectory.check_consistency()
+    def sample(self, batch_size=None):
+        if batch_size is None:
+            batch_size = self.batch_size
+        rand_indices = np.random.randint(0, len(self.samples), size=(batch_size,))
+        # rand_indices = [np.random.randint(0, len(self.samples)) for _ in range(batch_size)]
+        for idx in rand_indices:
+            self.samples[idx].times_was_sampled += 1 
+        return {
+            "observation":      [self.samples[idx].observation            for idx in rand_indices],
+            "action":           [self.samples[idx].action                 for idx in rand_indices],
+            "reward":           [self.samples[idx].reward                 for idx in rand_indices],
+            "next_observation": [self.samples[idx].next_observation       for idx in rand_indices],
+            "done":             [self.samples[idx].done                   for idx in rand_indices],
+        }
+    def mean_trajectory_return(self):
+        return np.mean(self.get_all_trajectory_returns())
+    def std_trajectory_return(self):
+        return np.std(self.get_all_trajectory_returns())
+    def merge(self, dataset):
+        self.check_consistency()
+        dataset.check_consistency()
+        for trajectory in dataset.trajectories:
+            for transition in trajectory.transitions:
+                self.append_sample_sequentially(transition.as_dict())
+            self.trajectories[-1].info = copy.deepcopy(trajectory.info)
+        self.check_consistency()
+        # assert(self.batch_size == dataset.batch_size)
+    def __str__(self):
+        printout = '\n \n '
+        printout += '\n ************************ '
+        printout += '\n *** Printing Dataset *** '
+        printout += '\n ************************ '
+        printout += '\n \n '
+        printout += '\n Number of Samples    : ' + str(len(self))
+        printout += '\n Dataset Trajectories : ' + str(self.nTrajectories()) + '\n'
+        for idx, trajectory in enumerate(self.trajectories):
+            printout += "\n >>> Trajectory id: " + str(idx) + '\n'
+            printout += trajectory.__str__()
+        if self._last_oar != None:
+            printout += "\n !!! Found incomplete transition !!! \n"
+            for key in self._last_oar:
+                printout += key + '\n'
+                printout += str(self._last_oar[key]) + "\n"
+        printout += '\n ************************ '
+        printout += '\n *** Dataset  Printed *** '
+        printout += '\n ************************ '
+        return printout
+    
+    def keep_top_fraction_of_trajectories(self, fraction: float, from_high_to_low = True):
+        self.sort(from_high_to_low=from_high_to_low)
+        trajectories = self.trajectories
+        import math
+        nTraj_to_keep = int(fraction * self.nTrajectories())
+        self.__init__()
+        for i in range(nTraj_to_keep):
+            self.append_trajectory(trajectories[i])
+        print("*** Kept ", self.nTrajectories(), " trajectories")
+
+    def keep_bottom_fraction_of_trajectories(self, fraction: float):
+        self.keep_top_fraction_of_trajectories(fraction=fraction, from_high_to_low=False)
+
+
+    def max_trajectory_return(self):
+        return max(self.get_all_trajectory_returns())
+    
+    def argmax_trajectory_return(self):
+        return np.argmax(self.get_all_trajectory_returns())
+    
+    def min_trajectory_return(self):
+        return min(self.get_all_trajectory_returns())
+    
+    def argmin_trajectory_return(self):
+        return np.argmin(self.get_all_trajectory_returns())
+    
+    def sort(self, from_high_to_low):
+        print("Warning: new dataset created!")
+        returns = [trajectory.get_return() for trajectory in self.trajectories]  
+        sorted_trajectories = sort_list(self.trajectories, returns, from_high_to_low)
+        self.__init__()
+        for traj in sorted_trajectories:
+            self.append_trajectory(traj)
+        
+    # useful to set all rewards to eg -1 and encourage reaching the goal faster
+    def set_all_rewards_to_value(self, value):
+        for sample in self.samples:
+            sample.reward = np.single(value)
+    
+    def scale_all_rewards_by_value(self, value):
+        for sample in self.samples:
+            sample.reward *= np.single(value)
+
+    def add_value_to_all_rewards(self, value):
+        for sample in self.samples:
+            sample.reward += np.single(value)
+
+    def increase_final_reward_by_value(self, value):
+        for trajectory in self.trajectories:
+            trajectory.transitions[-1].reward  += np.single(value)
+            
+    def append_eos_token_to_all_actions(self, eos_token):
+        for sample in self.samples:
+            sample.action += eos_token
+        
+    def push_all_rewards_at_the_end_of_the_trajectory(self):
+        for trajectory in self.trajectories:
+            trajectory.transitions[-1].reward  = np.single(trajectory.get_return())
+            for transition in trajectory.transitions[:-1]:
+                transition.reward = np.single(0)
+            assert(- len(trajectory) == trajectory.get_return() == trajectory.transitions[-1].reward)
+
+    def save(self, filename):
+        import json 
+        self.check_consistency()
+        with open(filename, "w") as final:
+            json.dump([sample.as_dict(as_string = True) for sample in self.samples], final)
+
+    def load(self, filename):
+        import json 
+        with open(filename, "r") as final:
+            data = json.load(final)
+            for sample in data:
+                self.append_sample_sequentially(sample)
+                
+    def times_was_sampled(self):
+        return [sample.times_was_sampled for sample in self.samples]
+    
+    def keep_only_trajectories_with_exact_key_and_value(self, key, value):
+        trajectories = self.trajectories
+        new_dataset = TrajectoryDataset()
+        for trajectory in trajectories:
+            if trajectory.info[key] == value:
+                new_dataset.append_trajectory(trajectory)
+        return new_dataset
+    
+    def construct_tabular_state_action_space(self):
+        self.state_space        = Counter()
+        self.action_space       = Counter()
+        self.state_action_space = Counter()
+        for sample in self.samples:
+            self.state_space.add(sample.observation)
+            self.action_space.add(sample.action)
+            self.state_action_space.add((sample.observation, sample.action))
+
+    def assert_deterministic(self):
+        successor_states = {}
+        rewards          = {}
+        for sample in self.samples:
+            sa = (sample.observation, sample.action)
+          
+            if sa not in rewards:
+                rewards[sa] = sample.reward
+
+            else:
+                assert(rewards[sa] == sample.reward)
+            
+            if sample.done: # end transition may be ill-defined
+                continue
+
+            if sa not in successor_states:
+                successor_states[sa] = sample.next_observation
+            else:
+                assert(successor_states[sa] == sample.next_observation)
+        
+class Counter():
+    def __init__(self):
+        self.register = {}
+    def add(self, item):
+        if item not in self.register:
+            self.register[item] = 1
+        else:
+            self.register[item] += 1
+    def contains(self, item):
+        return item in self.register
+
+    def n_samples(self, item):
+        return self.register[item]
+    
+class EmptyDataset():
+    def __init__(self, length):
+        self.length     = length
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, idx):
+        return [0]
+    
+def sort_list(list1, list2, from_high_to_low):
+    # Sorting the List1 based on List2
+    return [val for (_, val) in sorted(zip(list2, list1), key=lambda x: x[0], reverse=from_high_to_low)]

Qwen3-14B_Strategic_log.txt

@@ -0,0 +1,12 @@
+Traceback (most recent call last):
+  File "/home/jiashuo/anaconda3/envs/archer/bin/accelerate", line 7, in <module>
+    sys.exit(main())
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/accelerate_cli.py", line 50, in main
+    args.func(args)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/launch.py", line 1213, in launch_command
+    args, defaults, mp_from_config_flag = _validate_launch_command(args)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/launch.py", line 1043, in _validate_launch_command
+    defaults = load_config_from_file(args.config_file)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/config/config_args.py", line 46, in load_config_from_file
+    raise FileNotFoundError(
+FileNotFoundError: The passed configuration file `/home/jiashuo/codes/OfflineArcher/deepspeed_zero3.syaml` does not exist. Please pass an existing file to `accelerate launch`, or use the default one created through `accelerate config` and run `accelerate launch` without the `--config_file` argument.

Qwen3-14B_Word_log.txt

@@ -0,0 +1,285 @@
+The following values were not passed to `accelerate launch` and had defaults used instead:
+	`--num_cpu_threads_per_process` was set to `16` to improve out-of-box performance when training on CPUs
+To avoid this warning pass in values for each of the problematic parameters or run `accelerate config`.
+[2025-09-16 23:00:41,059] [INFO] [real_accelerator.py:260:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+[2025-09-16 23:00:42,764] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False
+W0916 23:00:42.933299 185693 site-packages/torch/distributed/run.py:774] 
+W0916 23:00:42.933299 185693 site-packages/torch/distributed/run.py:774] *****************************************
+W0916 23:00:42.933299 185693 site-packages/torch/distributed/run.py:774] Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. 
+W0916 23:00:42.933299 185693 site-packages/torch/distributed/run.py:774] *****************************************
+[rank: 0] Seed set to 42
+[rank: 3] Seed set to 42
+[rank: 2] Seed set to 42
+[rank: 1] Seed set to 42
+[rank: 3] Seed set to 42
+[rank: 0] Seed set to 42
+`torch_dtype` is deprecated! Use `dtype` instead!
+[rank: 2] Seed set to 42
+
+
+`torch_dtype` is deprecated! Use `dtype` instead!
+[rank: 1] Seed set to 42
+
+
+`torch_dtype` is deprecated! Use `dtype` instead!
+
+`torch_dtype` is deprecated! Use `dtype` instead!
+`torch_dtype` is deprecated! Use `dtype` instead!
+`torch_dtype` is deprecated! Use `dtype` instead!
+`torch_dtype` is deprecated! Use `dtype` instead!
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['pooler.dense.bias', 'pooler.dense.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+*** Master Warning - Are these used? *** 
+[2025-09-16 23:00:53,766] [INFO] [real_accelerator.py:260:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+[2025-09-16 23:00:53,921] [INFO] [real_accelerator.py:260:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/fabric/connector.py:571: `precision=bf16` is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!
+[2025-09-16 23:00:54,516] [INFO] [real_accelerator.py:260:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+[2025-09-16 23:00:54,670] [INFO] [real_accelerator.py:260:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+[2025-09-16 23:00:55,689] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False
+[2025-09-16 23:00:55,761] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False
+initializing deepspeed distributed: GLOBAL_RANK: 3, MEMBER: 4/4
+initializing deepspeed distributed: GLOBAL_RANK: 2, MEMBER: 3/4
+[2025-09-16 23:00:56,385] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False
+GPU available: True (cuda), used: True
+TPU available: False, using: 0 TPU cores
+HPU available: False, using: 0 HPUs
+initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/4
+[2025-09-16 23:00:56,741] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False
+initializing deepspeed distributed: GLOBAL_RANK: 1, MEMBER: 2/4
+wandb: Currently logged in as: jessie-w to https://api.wandb.ai. Use `wandb login --relogin` to force relogin
+wandb: creating run
+wandb: Tracking run with wandb version 0.21.4
+wandb: Run data is saved locally in ./wandb/run-20250916_230057-ao2fiuap
+wandb: Run `wandb offline` to turn off syncing.
+wandb: Syncing run Test-AC-critic_expectile_0.9-inv_temp_1.0
+wandb: ⭐️ View project at https://wandb.ai/jessie-w/WordTaboo-Official
+wandb: 🚀 View run at https://wandb.ai/jessie-w/WordTaboo-Official/runs/ao2fiuap
+The length of the dataset is:  13220
+
+ *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming
+The length of the dataset is:  13220
+
+ *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming
+The length of the dataset is:  13220
+
+ *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming
+/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:751: Checkpoint directory /home/jiashuo/codes/OfflineArcher/models exists and is not empty.
+The length of the dataset is:  13220
+
+ *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming
+LOCAL_RANK: 2 - CUDA_VISIBLE_DEVICES: [4,5,6,7]
+LOCAL_RANK: 3 - CUDA_VISIBLE_DEVICES: [4,5,6,7]
+LOCAL_RANK: 1 - CUDA_VISIBLE_DEVICES: [4,5,6,7]
+Enabling DeepSpeed BF16. Model parameters and inputs will be cast to `bfloat16`.
+LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [4,5,6,7]
+Parameter Offload - Persistent parameters statistics: param_count = 601, numel = 5932040
+/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/fit_loop.py:527: Found 1063 module(s) in eval mode at the start of training. This may lead to unexpected behavior during training. If this is intentional, you can ignore this warning.
+
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/main.py", line 33, in <module>
+[rank2]:     cli_main()
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/main.py", line 22, in cli_main
+[rank2]:     cli = LightningCLI(
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/cli.py", line 414, in __init__
+[rank2]:     self._run_subcommand(self.subcommand)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/cli.py", line 747, in _run_subcommand
+[rank2]:     fn(**fn_kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/trainer.py", line 560, in fit
+[rank2]:     call._call_and_handle_interrupt(
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/call.py", line 48, in _call_and_handle_interrupt
+[rank2]:     return trainer.strategy.launcher.launch(trainer_fn, *args, trainer=trainer, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/strategies/launchers/subprocess_script.py", line 105, in launch
+[rank2]:     return function(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/trainer.py", line 598, in _fit_impl
+[rank2]:     self._run(model, ckpt_path=ckpt_path)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/trainer.py", line 1011, in _run
+[rank2]:     results = self._run_stage()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/trainer.py", line 1055, in _run_stage
+[rank2]:     self.fit_loop.run()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/fit_loop.py", line 216, in run
+[rank2]:     self.advance()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/fit_loop.py", line 458, in advance
+[rank2]:     self.epoch_loop.run(self._data_fetcher)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/training_epoch_loop.py", line 152, in run
+[rank2]:     self.advance(data_fetcher)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/training_epoch_loop.py", line 350, in advance
+[rank2]:     batch_output = self.manual_optimization.run(kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/manual.py", line 95, in run
+[rank2]:     self.advance(kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/manual.py", line 115, in advance
+[rank2]:     training_step_output = call._call_strategy_hook(trainer, "training_step", *kwargs.values())
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/trainer/call.py", line 329, in _call_strategy_hook
+[rank2]:     output = fn(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/strategies/strategy.py", line 390, in training_step
+[rank2]:     return self._forward_redirection(self.model, self.lightning_module, "training_step", *args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/strategies/strategy.py", line 641, in __call__
+[rank2]:     wrapper_output = wrapper_module(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1784, in _call_impl
+[rank2]:     return forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/utils/nvtx.py", line 20, in wrapped_fn
+[rank2]:     ret_val = func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/engine.py", line 2131, in forward
+[rank2]:     loss = self.module(*inputs, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/lightning/pytorch/strategies/strategy.py", line 634, in wrapped_forward
+[rank2]:     out = method(*_args, **_kwargs)
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/Algorithms.py", line 533, in training_step
+[rank2]:     actor_loss, actor_log = self.actor_loss(batch)
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/Algorithms.py", line 611, in <lambda>
+[rank2]:     self.actor_loss = lambda batch: self.awr_loss(**batch)
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/Algorithms.py", line 615, in awr_loss
+[rank2]:     log_prob = self.actor.get_logsum_prob(observation, action)
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/Algorithms.py", line 130, in get_logsum_prob
+[rank2]:     generated_probabilities = self.to_tokens_and_logprobs(alltext)
+[rank2]:   File "/home/jiashuo/codes/OfflineArcher/Algorithms.py", line 163, in to_tokens_and_logprobs
+[rank2]:     outputs = self.model(input_ids)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/peft/peft_model.py", line 1850, in forward
+[rank2]:     return self.base_model(
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/peft/tuners/tuners_utils.py", line 222, in forward
+[rank2]:     return self.model.forward(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/utils/generic.py", line 940, in wrapper
+[rank2]:     output = func(self, *args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/models/qwen3/modeling_qwen3.py", line 480, in forward
+[rank2]:     outputs: BaseModelOutputWithPast = self.model(
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/utils/generic.py", line 1064, in wrapper
+[rank2]:     outputs = func(self, *args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/models/qwen3/modeling_qwen3.py", line 410, in forward
+[rank2]:     hidden_states = decoder_layer(
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/modeling_layers.py", line 94, in __call__
+[rank2]:     return super().__call__(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/utils/deprecation.py", line 172, in wrapped_func
+[rank2]:     return func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/models/qwen3/modeling_qwen3.py", line 275, in forward
+[rank2]:     hidden_states = self.mlp(hidden_states)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1827, in inner
+[rank2]:     result = forward_call(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/transformers/models/qwen3/modeling_qwen3.py", line 82, in forward
+[rank2]:     down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1773, in _wrapped_call_impl
+[rank2]:     return self._call_impl(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1879, in _call_impl
+[rank2]:     return inner()
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1816, in inner
+[rank2]:     args_result = hook(self, args)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/_dynamo/eval_frame.py", line 929, in _fn
+[rank2]:     return fn(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/parameter_offload.py", line 298, in _pre_forward_module_hook
+[rank2]:     self.pre_sub_module_forward_function(module)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/utils/_contextlib.py", line 120, in decorate_context
+[rank2]:     return func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/parameter_offload.py", line 473, in pre_sub_module_forward_function
+[rank2]:     param_coordinator.fetch_sub_module(sub_module, forward=True)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/_dynamo/eval_frame.py", line 929, in _fn
+[rank2]:     return fn(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/utils/nvtx.py", line 20, in wrapped_fn
+[rank2]:     ret_val = func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/utils/_contextlib.py", line 120, in decorate_context
+[rank2]:     return func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/partitioned_param_coordinator.py", line 415, in fetch_sub_module
+[rank2]:     self.__all_gather_params(params_to_prefetch, forward)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/utils/nvtx.py", line 20, in wrapped_fn
+[rank2]:     ret_val = func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/partitioned_param_coordinator.py", line 475, in __all_gather_params
+[rank2]:     self.__all_gather_params_(nonquantized_params, forward, quantize=self.zero_quantized_weights)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/partitioned_param_coordinator.py", line 504, in __all_gather_params_
+[rank2]:     handle = param_group[0].all_gather_coalesced(param_group, quantize=quantize)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/utils/nvtx.py", line 20, in wrapped_fn
+[rank2]:     ret_val = func(*args, **kwargs)
+[rank2]:   File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/deepspeed/runtime/zero/partition_parameters.py", line 1325, in all_gather_coalesced
+[rank2]:     param_buffer = torch.empty(
+[rank2]: torch.AcceleratorError: CUDA error: out of memory
+[rank2]: Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
+
+W0916 23:03:30.410014 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:900] Sending process 185929 closing signal SIGTERM
+W0916 23:03:30.412096 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:900] Sending process 185930 closing signal SIGTERM
+W0916 23:03:30.414456 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:900] Sending process 185932 closing signal SIGTERM
+W0916 23:04:00.415664 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:919] Unable to shutdown process 185929 via Signals.SIGTERM, forcefully exiting via Signals.SIGKILL
+W0916 23:04:00.757989 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:919] Unable to shutdown process 185930 via Signals.SIGTERM, forcefully exiting via Signals.SIGKILL
+W0916 23:04:01.076958 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:919] Unable to shutdown process 185932 via Signals.SIGTERM, forcefully exiting via Signals.SIGKILL
+E0916 23:04:01.370846 185693 site-packages/torch/distributed/elastic/multiprocessing/api.py:874] failed (exitcode: 1) local_rank: 2 (pid: 185931) of binary: /home/jiashuo/anaconda3/envs/archer/bin/python3.10
+Traceback (most recent call last):
+  File "/home/jiashuo/anaconda3/envs/archer/bin/accelerate", line 7, in <module>
+    sys.exit(main())
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/accelerate_cli.py", line 50, in main
+    args.func(args)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/launch.py", line 1220, in launch_command
+    deepspeed_launcher(args)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/accelerate/commands/launch.py", line 906, in deepspeed_launcher
+    distrib_run.run(args)
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/distributed/run.py", line 892, in run
+    elastic_launch(
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/distributed/launcher/api.py", line 143, in __call__
+    return launch_agent(self._config, self._entrypoint, list(args))
+  File "/home/jiashuo/anaconda3/envs/archer/lib/python3.10/site-packages/torch/distributed/launcher/api.py", line 277, in launch_agent
+    raise ChildFailedError(
+torch.distributed.elastic.multiprocessing.errors.ChildFailedError: 
+============================================================
+/home/jiashuo/codes/OfflineArcher/main.py FAILED
+------------------------------------------------------------
+Failures:
+  <NO_OTHER_FAILURES>
+------------------------------------------------------------
+Root Cause (first observed failure):
+[0]:
+  time      : 2025-09-16_23:03:30
+  host      : somea6k.local
+  rank      : 2 (local_rank: 2)
+  exitcode  : 1 (pid: 185931)
+  error_file: <N/A>
+  traceback : To enable traceback see: https://pytorch.org/docs/stable/elastic/errors.html
+============================================================

README.md

@@ -0,0 +1,57 @@
+# OfflineArcher
+Research Code for the Offline Experiments of "ArCHer: Training Language Model Agents via Hierarchical Multi-Turn RL" 
+
+[Yifei Zhou](https://yifeizhou02.github.io/), [Andrea Zanette](https://azanette.com/), [Jiayi Pan](https://www.jiayipan.me/), [Aviral Kumar](https://aviralkumar2907.github.io/), [Sergey Levine](https://people.eecs.berkeley.edu/~svlevine/)
+
+![archer_diagram 001](https://github.com/YifeiZhou02/ArCHer/assets/83000332/b874432a-d330-49a5-906c-bba37e17f831)
+
+
+This repo supports the following methods:
+
+- [Offline ArCHer][1]
+- Offline Filtered BC
+- Offline BC
+
+[1]: https://github.com/YifeiZhou02/ArCHer
+
+And the following environments
+- [Twenty Questions][2]
+
+[2]: https://lmrl-gym.github.io/
+
+
+## Quick Start
+### 1. Install Dependencies
+```bash
+conda create -n archer python==3.10
+conda activate archer
+
+git clone https://github.com/andreazanette/OfflineArcher
+cd OfflineArcher
+python -m pip install -e .
+```
+### 2. Download Datasets and Oracles
+Offline datasets and Oracles checkpoints used in the paper can be found [here](https://drive.google.com/drive/folders/1pRocQI0Jv479G4vNMtQn1JOq8Shf2B6U?usp=sharing).
+You will need to create an "oracles" and "datasets" folder and put the oracle and dataset in such folders.
+The oracle for Twenty Questions should be named 20q_t5_oracle.pt and the dataset should be called "twenty_questions.json".
+
+### 3. Run Experiments
+You can directly run experiments by runnig the launch scripts. For example, in order to lauch Offline Archer on Twenty Question simply run
+```bash
+. submit_OfflineArcher_TwentyQuestions.sh
+```
+The code uses the torch lightning framework. Please refer to the documentation of torch lightning (https://lightning.ai/docs/pytorch/stable/) for additional information, such as using different flags when launching the code.
+For example, in order to run on GPU 0 please add 
+--trainer.devices=[0] to the launch script.
+
+### 4. Citing Archer
+```
+@misc{zhou2024archer,
+      title={ArCHer: Training Language Model Agents via Hierarchical Multi-Turn RL}, 
+      author={Yifei Zhou and Andrea Zanette and Jiayi Pan and Sergey Levine and Aviral Kumar},
+      year={2024},
+      eprint={2402.19446},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+

SimulateOnEnv.py

@@ -0,0 +1,40 @@
+import torch 
+
+def batch_simulate_on_environment(policy, env, verbose = True):
+    if verbose:
+        print("*** In batch_simulate_on_environment ***")
+    
+    from Dataset import Trajectory, TrajectoryDataset
+    from math import ceil
+
+    dataset = TrajectoryDataset()
+
+    trajectories = [Trajectory() for _ in range(env.bsize)]
+    batch_obs = env.reset() 
+    batch_done = [False,]*env.bsize
+    while not all(batch_done):
+        with torch.no_grad():
+            actions = policy(batch_obs)
+        batch_feedback = env.step(actions)
+        for i, feedback in zip(range(env.bsize), batch_feedback):
+            if feedback is None:
+                continue
+
+            next_obs, r, done = feedback
+            
+            trajectories[i].append({"observation": batch_obs[i],
+                                    "action": actions[i], 
+                                    "reward": r,
+                                    "next_observation": next_obs, 
+                                    "done": done, 
+                                    })
+            batch_obs[i] = next_obs
+            batch_done[i] = done
+    for trajectory in trajectories:
+        dataset.append_trajectory(trajectory)
+        print(trajectory.transitions[-1].next_observation)
+
+    dataset.check_consistency()
+    if verbose:
+        print("Data Coollection is Complete. Returns: \n", dataset.get_all_trajectory_returns(), "\n with mean: ",dataset.mean_trajectory_return(), "\n" )
+    return dataset

Tasks.py

@@ -0,0 +1,476 @@
+from lightning import LightningDataModule
+import torch.utils.data as data
+from Dataset import TrajectoryDataset, EmptyDataset
+from SimulateOnEnv import batch_simulate_on_environment
+import numpy as np
+from copy import deepcopy
+import sys
+import random
+
+
+def rsa_reward(num_feature, min_turns, conv_turn, gamma=2.0):
+    """
+    Nonlinear normalization function, returns u ∈ [0, 1]
+    - num_feature = min_turns -> u = 1
+    - num_feature = conv_turn -> u = 0
+    - The closer to min_turns, the slower it approaches 1
+    """
+    if num_feature == min_turns:
+        return 1
+    # Normalize to [0,1]
+    u = (conv_turn - num_feature) / (min_turns - num_feature)
+    # Keep direction (support num_feature < min_turns)
+    return max(0, min(1, u**gamma))
+
+
+class Task(LightningDataModule):
+    def __init__(self, batch_size: int, n_traj_eval: int, **kwargs):
+        super().__init__(**kwargs)
+        self.batch_size = batch_size
+        self.eval_batch_size = self.batch_size
+        self.n_traj_eval = n_traj_eval
+
+        # Set Defaults
+        self.shuffle = True
+        self.drop_last = True  # skips last batch to make sure gradient accumulation works as intended
+
+    def setup(self, stage: str):
+        raise NotImplementedError
+
+    def train_dataloader(self):
+        return data.DataLoader(
+            dataset=self.dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            drop_last=self.drop_last,
+            num_workers=8,
+            pin_memory=True,
+            persistent_workers=True,
+        )
+
+    def val_dataloader(self):
+        return data.DataLoader(
+            dataset=EmptyDataset(length=self.n_traj_eval),
+            batch_size=self.eval_batch_size,
+            pin_memory=True,
+        )
+
+    def get_eval_log(self, **kwargs):
+        pass
+
+    def teardown(self, stage: str):
+        # Used to clean-up when the run is finished
+        pass
+
+
+class TwentyQuestions(Task):
+    def __init__(self, batch_size: int, n_traj_eval: int, word_list=None, **kwargs):
+        super().__init__(batch_size, n_traj_eval, **kwargs)
+
+        self.word_list = word_list
+        self.max_horizon = 20
+
+    def setup(self, stage: str):
+        self.dataset = self.read_data()
+        self.dataset.check_consistency()
+        print(
+            "\n *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming"
+        )
+
+    def read_data(self):
+        import json
+        from Dataset import TrajectoryDataset
+
+        f = open("datasets/20q_train.json")
+        data = json.load(f)
+        dataset = TrajectoryDataset()
+
+        for game in data:
+            assert len(game["lines"]) <= 20
+            history = "Questions:\n"  # assertion is checked with history = ''
+            for interaction in game["lines"]:
+                yesAnswer = interaction[-5:] == " Yes."
+                noAnswer = interaction[-4:] == " No."
+                assert yesAnswer or noAnswer
+                observation = history
+
+                done = (
+                    True if interaction == game["lines"][-1] else False
+                )  # if the interaction is the last interaction we are done
+                reward = 0 if done and game["correct"] else -1
+
+                if yesAnswer:
+                    action = interaction[:-5]
+                if noAnswer:
+                    action = interaction[:-4]
+
+                history += interaction + "\n"
+                dataset.append_observation_action_reward(observation, action, reward)
+            dataset.append_terminal_observation(
+                history,
+                trajectory_info={"correct": game["correct"], "word": game["word"]},
+            )
+
+        dataset.check_consistency()
+        return dataset
+
+
+class RSAGame(Task):
+    def __init__(
+        self,
+        base_model: str,
+        batch_size: int,
+        n_traj_eval: int,
+        word_list=None,
+        **kwargs,
+    ):
+        super().__init__(batch_size, n_traj_eval, **kwargs)
+        self.base_model = base_model
+
+        self.word_list = word_list
+        self.max_horizon = 20
+
+    def setup(self, stage: str):
+        self.dataset = self.read_data()
+        self.dataset.check_consistency()
+        print(
+            "\n *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming"
+        )
+
+    def read_data(self):
+        import json
+        from Dataset import TrajectoryDataset
+        from rsa_game import get_game_outcome, randomly_convert_game_history_to_query
+
+        with open(
+            f"rsa/{self.base_model}_sampling_all_targets_results.json"
+        ) as f:
+            data = json.load(f)
+        with open(
+            "rsa/reasoning_dialogs.json"
+        ) as f:
+            for key, value in json.load(f).items():
+                instance = {}
+                instance["history"] = value["dialog"]
+                instance["target"] = value["target_referent"].split(" ")
+                instance["min_turns"] = len(value["dialog"])
+                instance["max_turns"] = len(instance["target"]) * 2
+                instance["object_list"] = value["referent_set"]
+                data.append(instance)
+        
+        dataset = TrajectoryDataset()
+
+        for game in random.sample(data, 3200):
+            is_valid = True
+            for message in game["history"]:
+                if message["content"] == "":
+                    is_valid = False
+                    break
+            if not is_valid:
+                continue
+
+            outcome, history_length = get_game_outcome(
+                game["history"], game["target"], game["min_turns"]
+            )
+            if outcome == "game wins":
+                reward = rsa_reward(
+                    len(game["target"]) * 2, game["min_turns"] * 2, history_length
+                )
+            else:
+                continue
+                
+            if reward == 0:
+                continue
+
+            for idx, interaction in enumerate(game["history"][:history_length]):
+                query = randomly_convert_game_history_to_query(
+                    game["history"][:idx],
+                    target=game["target"],
+                    min_turns=game["min_turns"],
+                    object_list=game["object_list"],
+                )
+                target = interaction["content"]
+
+                done = (
+                    True if idx >= history_length - 2 else False
+                )  # if the interaction is the last interaction we are done
+                reward = 0 if done else reward
+
+                dataset.append_observation_action_reward(query, target, reward)
+
+            history = randomly_convert_game_history_to_query(
+                game["history"],
+                target=game["target"],
+                min_turns=game["min_turns"],
+                object_list=game["object_list"],
+            )
+            dataset.append_terminal_observation(
+                history,
+                trajectory_info={
+                    "object_list": game["object_list"],
+                    "target": game["target"],
+                },
+            )
+
+        print("The length of the dataset is: ", len(dataset))
+        dataset.check_consistency()
+        return dataset
+
+
+class WordTaboo(Task):
+    def __init__(
+        self,
+        base_model: str,
+        batch_size: int,
+        n_traj_eval: int,
+        word_list=None,
+        **kwargs,
+    ):
+        super().__init__(batch_size, n_traj_eval, **kwargs)
+
+        self.base_model = base_model
+        self.word_list = word_list
+        self.max_horizon = 20
+
+    def setup(self, stage: str):
+        self.dataset = self.read_data()
+        self.dataset.check_consistency()
+        print(
+            "\n *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming"
+        )
+
+    def read_data(self):
+        import json
+        from Dataset import TrajectoryDataset
+        from word_taboo import get_game_outcome, randomly_convert_game_history_to_query
+
+        with open(
+            f"wordtaboo/{self.base_model}_sampling_all_targets_results.json", "r"
+        ) as f:
+            data = json.load(f)
+        with open(
+            "wordtaboo/llm_game_top_test_results.json", "r"
+        ) as f:
+            data.extend(json.load(f))
+
+        dataset = TrajectoryDataset()
+
+        for game in data:
+            is_valid = True
+            for message in game["history"]:
+                if message["content"] == "":
+                    is_valid = False
+                    break
+            if not is_valid:
+                continue
+
+            outcome, history_length = get_game_outcome(
+                game["history"], game["target"], game["max_turns"]
+            )
+
+            if outcome == "defender wins":
+                winner = "defender"
+
+            elif outcome == "attacker wins":
+                if self.base_model == "Qwen3-14B":
+                    if random.random() < 0.85:  # 0.85 for qwen3; 0.9 for llama3
+                        continue
+                else:
+                    if random.random() < 0.9:  # 0.85 for qwen3; 0.9 for llama3
+                        continue
+                winner = "attacker"
+
+            else:
+                continue
+
+            for idx, interaction in enumerate(game["history"][:history_length]):
+                if interaction["role"] != winner:
+                    continue
+
+                query = randomly_convert_game_history_to_query(
+                    game["history"][:idx],
+                    target=game["target"],
+                    max_turns=game["max_turns"],
+                )
+
+                target = interaction["content"]
+
+                done = (
+                    True if idx >= history_length - 2 else False
+                )  # if the interaction is the last interaction we are done
+                reward = 0 if done else 1
+
+                dataset.append_observation_action_reward(query, target, reward)
+
+        history = randomly_convert_game_history_to_query(
+            game["history"], game["target"], game["max_turns"]
+        )
+        dataset.append_terminal_observation(
+            history, trajectory_info={"target": game["target"]}
+        )
+        print("The length of the dataset is: ", len(dataset))
+        dataset.check_consistency()
+        return dataset
+
+
+class StrategicDialogue(Task):
+    def __init__(
+        self,
+        base_model: str,
+        batch_size: int,
+        n_traj_eval: int,
+        word_list=None,
+        **kwargs,
+    ):
+        super().__init__(batch_size, n_traj_eval, **kwargs)
+        self.base_model = base_model
+
+        self.word_list = word_list
+        self.max_horizon = 20
+
+    def setup(self, stage: str):
+        self.dataset = self.read_data()
+        self.dataset.check_consistency()
+        print(
+            "\n *** Dataset Trimming Now Disabled. Please Called the Subroutine for triming"
+        )
+
+    def read_data(self):
+        import json
+        from Dataset import TrajectoryDataset
+        from word_taboo import get_game_outcome, randomly_convert_game_history_to_query
+
+        with open(
+            f"wordtaboo/{self.base_model}_sampling_all_targets_results.json", "r"
+        ) as f:
+            data = json.load(f)
+        with open(
+            "wordtaboo/llm_game_top_test_results.json", "r"
+        ) as f:
+            data.extend(json.load(f))
+
+        dataset = TrajectoryDataset()
+
+        for game in data:
+            is_valid = True
+            for message in game["history"]:
+                if message["content"] == "":
+                    is_valid = False
+                    break
+            if not is_valid:
+                continue
+
+            outcome, history_length = get_game_outcome(
+                game["history"], game["target"], game["max_turns"]
+            )
+
+            if outcome == "defender wins":
+                winner = "defender"
+
+            elif outcome == "attacker wins":
+                if self.base_model == "Qwen3-14B":
+                    if random.random() < 0.85:  # 0.85 for qwen3; 0.9 for llama3
+                        continue
+                else:
+                    if random.random() < 0.9:  # 0.85 for qwen3; 0.9 for llama3
+                        continue
+                winner = "attacker"
+
+            else:
+                continue
+
+            for idx, interaction in enumerate(game["history"][:history_length]):
+                if interaction["role"] != winner:
+                    continue
+
+                query = randomly_convert_game_history_to_query(
+                    game["history"][:idx],
+                    target=game["target"],
+                    max_turns=game["max_turns"],
+                )
+
+                target = interaction["content"]
+
+                done = (
+                    True if idx >= history_length - 2 else False
+                )  # if the interaction is the last interaction we are done
+                reward = 0 if done else 1
+
+                dataset.append_observation_action_reward(query, target, reward)
+
+        history = randomly_convert_game_history_to_query(
+            game["history"], game["target"], game["max_turns"]
+        )
+        dataset.append_terminal_observation(
+            history, trajectory_info={"target": game["target"]}
+        )
+
+        from rsa_game import get_game_outcome, randomly_convert_game_history_to_query
+        with open(
+            f"rsa/{self.base_model}_sampling_all_targets_results.json"
+        ) as f:
+            data = json.load(f)
+        with open(
+            "rsa/reasoning_dialogs.json"
+        ) as f:
+            for key, value in json.load(f).items():
+                instance = {}
+                instance["history"] = value["dialog"]
+                instance["target"] = value["target_referent"].split(" ")
+                instance["min_turns"] = len(value["dialog"])
+                instance["max_turns"] = len(instance["target"]) * 2
+                instance["object_list"] = value["referent_set"]
+                data.append(instance)
+
+        for game in random.sample(data, 3200):
+            is_valid = True
+            for message in game["history"]:
+                if message["content"] == "":
+                    is_valid = False
+                    break
+            if not is_valid:
+                continue
+
+            outcome, history_length = get_game_outcome(
+                game["history"], game["target"], game["min_turns"]
+            )
+            if outcome == "game wins":
+                reward = rsa_reward(
+                    len(game["target"]) * 2, game["min_turns"] * 2, history_length
+                )
+            else:
+                continue
+
+            for idx, interaction in enumerate(game["history"][:history_length]):
+                query = randomly_convert_game_history_to_query(
+                    game["history"][:idx],
+                    target=game["target"],
+                    min_turns=game["min_turns"],
+                    object_list=game["object_list"],
+                )
+                target = interaction["content"]
+
+                done = (
+                    True if idx >= history_length - 2 else False
+                )  # if the interaction is the last interaction we are done
+                reward = 0 if done else reward
+
+                dataset.append_observation_action_reward(query, target, reward)
+
+        history = randomly_convert_game_history_to_query(
+            game["history"],
+            target=game["target"],
+            min_turns=game["min_turns"],
+            object_list=game["object_list"],
+        )
+        dataset.append_terminal_observation(
+            history,
+            trajectory_info={
+                "object_list": game["object_list"],
+                "target": game["target"],
+            },
+        )
+        
+        print("The length of the dataset is: ", len(dataset))
+        dataset.check_consistency()
+        return dataset

archer.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: archer
+Version: 0.1.0
+Summary: Research code for Offline ArCHer (Actor Critic Framework with Hierarchical Structures)
+Home-page: https://github.com/andreazanette/OfflineArcher.git
+Author: Andrea Zanette
+License: MIT
+Keywords: ArCHer
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: lightning
+Requires-Dist: jsonargparse
+Requires-Dist: lightning-utilities
+Requires-Dist: numpy
+Requires-Dist: pytorch-lightning
+Requires-Dist: safetensors
+Requires-Dist: sentencepiece
+Requires-Dist: torch
+Requires-Dist: torchmetrics
+Requires-Dist: tqdm
+Requires-Dist: transformers
+Requires-Dist: wandb
+Requires-Dist: jsonargparse[signatures]>=4.26.1
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OfflineArcher
+Research Code for the Offline Experiments of "ArCHer: Training Language Model Agents via Hierarchical Multi-Turn RL" 
+
+[Yifei Zhou](https://yifeizhou02.github.io/), [Andrea Zanette](https://azanette.com/), [Jiayi Pan](https://www.jiayipan.me/), [Aviral Kumar](https://aviralkumar2907.github.io/), [Sergey Levine](https://people.eecs.berkeley.edu/~svlevine/)
+
+![archer_diagram 001](https://github.com/YifeiZhou02/ArCHer/assets/83000332/b874432a-d330-49a5-906c-bba37e17f831)
+
+
+This repo supports the following methods:
+
+- [Offline ArCHer][1]
+- Offline Filtered BC
+- Offline BC
+
+[1]: https://github.com/YifeiZhou02/ArCHer
+
+And the following environments
+- [Twenty Questions][2]
+
+[2]: https://lmrl-gym.github.io/
+
+
+## Quick Start
+### 1. Install Dependencies
+```bash
+conda create -n archer python==3.10
+conda activate archer
+
+git clone https://github.com/andreazanette/OfflineArcher
+cd OfflineArcher
+python -m pip install -e .
+```
+### 2. Download Datasets and Oracles
+Offline datasets and Oracles checkpoints used in the paper can be found [here](https://drive.google.com/drive/folders/1pRocQI0Jv479G4vNMtQn1JOq8Shf2B6U?usp=sharing).
+You will need to create an "oracles" and "datasets" folder and put the oracle and dataset in such folders.
+The oracle for Twenty Questions should be named 20q_t5_oracle.pt and the dataset should be called "twenty_questions.json".
+
+### 3. Run Experiments
+You can directly run experiments by runnig the launch scripts. For example, in order to lauch Offline Archer on Twenty Question simply run
+```bash
+. submit_OfflineArcher_TwentyQuestions.sh
+```
+The code uses the torch lightning framework. Please refer to the documentation of torch lightning (https://lightning.ai/docs/pytorch/stable/) for additional information, such as using different flags when launching the code.
+For example, in order to run on GPU 0 please add 
+--trainer.devices=[0] to the launch script.
+
+### 4. Citing Archer
+```
+@misc{zhou2024archer,
+      title={ArCHer: Training Language Model Agents via Hierarchical Multi-Turn RL}, 
+      author={Yifei Zhou and Andrea Zanette and Jiayi Pan and Sergey Levine and Aviral Kumar},
+      year={2024},
+      eprint={2402.19446},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+

archer.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+setup.py
+archer.egg-info/PKG-INFO
+archer.egg-info/SOURCES.txt
+archer.egg-info/dependency_links.txt
+archer.egg-info/requires.txt
+archer.egg-info/top_level.txt

archer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

archer.egg-info/requires.txt

@@ -0,0 +1,13 @@
+lightning
+jsonargparse
+lightning-utilities
+numpy
+pytorch-lightning
+safetensors
+sentencepiece
+torch
+torchmetrics
+tqdm
+transformers
+wandb
+jsonargparse[signatures]>=4.26.1

archer.egg-info/top_level.txt

@@ -0,0 +1 @@
+

archer.tar.gz

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

checkpoints/archer_Llama3-8B-I_strategic/README.md

@@ -0,0 +1,207 @@
+---
+base_model: /home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_strategic/merged_model
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:/home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_strategic/merged_model
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.17.1

checkpoints/archer_Llama3-8B-I_strategic/adapter_config.json

@@ -0,0 +1,37 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "/home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_strategic/merged_model",
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "qalora_group_size": 16,
+  "r": 8,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

checkpoints/archer_Llama3-8B-I_strategic/adapter_model.safetensors

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

checkpoints/archer_Llama3-8B-I_strategic/chat_template.jinja

@@ -0,0 +1,5 @@
+{% set loop_messages = messages %}{% for message in loop_messages %}{% set content = '<|start_header_id|>' + message['role'] + '<|end_header_id|>
+
+'+ message['content'] | trim + '<|eot_id|>' %}{% if loop.index0 == 0 %}{% set content = bos_token + content %}{% endif %}{{ content }}{% endfor %}{% if add_generation_prompt %}{{ '<|start_header_id|>assistant<|end_header_id|>
+
+' }}{% endif %}

checkpoints/archer_Llama3-8B-I_strategic/special_tokens_map.json

@@ -0,0 +1,23 @@
+{
+  "bos_token": {
+    "content": "<|begin_of_text|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|eot_id|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|eot_id|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

checkpoints/archer_Llama3-8B-I_strategic/tokenizer.json

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

checkpoints/archer_Llama3-8B-I_strategic/tokenizer_config.json

@@ -0,0 +1,2065 @@
+{
+  "added_tokens_decoder": {
+    "128000": {
+      "content": "<|begin_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128001": {
+      "content": "<|end_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128002": {
+      "content": "<|reserved_special_token_0|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128003": {
+      "content": "<|reserved_special_token_1|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128004": {
+      "content": "<|reserved_special_token_2|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128005": {
+      "content": "<|reserved_special_token_3|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128006": {
+      "content": "<|start_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128007": {
+      "content": "<|end_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128008": {
+      "content": "<|reserved_special_token_4|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128009": {
+      "content": "<|eot_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128010": {
+      "content": "<|reserved_special_token_5|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128011": {
+      "content": "<|reserved_special_token_6|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128012": {
+      "content": "<|reserved_special_token_7|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128013": {
+      "content": "<|reserved_special_token_8|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128014": {
+      "content": "<|reserved_special_token_9|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128015": {
+      "content": "<|reserved_special_token_10|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128016": {
+      "content": "<|reserved_special_token_11|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128017": {
+      "content": "<|reserved_special_token_12|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128018": {
+      "content": "<|reserved_special_token_13|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128019": {
+      "content": "<|reserved_special_token_14|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128020": {
+      "content": "<|reserved_special_token_15|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128021": {
+      "content": "<|reserved_special_token_16|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128022": {
+      "content": "<|reserved_special_token_17|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128023": {
+      "content": "<|reserved_special_token_18|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128024": {
+      "content": "<|reserved_special_token_19|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128025": {
+      "content": "<|reserved_special_token_20|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128026": {
+      "content": "<|reserved_special_token_21|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128027": {
+      "content": "<|reserved_special_token_22|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128028": {
+      "content": "<|reserved_special_token_23|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128029": {
+      "content": "<|reserved_special_token_24|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128030": {
+      "content": "<|reserved_special_token_25|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128031": {
+      "content": "<|reserved_special_token_26|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128032": {
+      "content": "<|reserved_special_token_27|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128033": {
+      "content": "<|reserved_special_token_28|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128034": {
+      "content": "<|reserved_special_token_29|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128035": {
+      "content": "<|reserved_special_token_30|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128036": {
+      "content": "<|reserved_special_token_31|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128037": {
+      "content": "<|reserved_special_token_32|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128038": {
+      "content": "<|reserved_special_token_33|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128039": {
+      "content": "<|reserved_special_token_34|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128040": {
+      "content": "<|reserved_special_token_35|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128041": {
+      "content": "<|reserved_special_token_36|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128042": {
+      "content": "<|reserved_special_token_37|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128043": {
+      "content": "<|reserved_special_token_38|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128044": {
+      "content": "<|reserved_special_token_39|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128045": {
+      "content": "<|reserved_special_token_40|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128046": {
+      "content": "<|reserved_special_token_41|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128047": {
+      "content": "<|reserved_special_token_42|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128048": {
+      "content": "<|reserved_special_token_43|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128049": {
+      "content": "<|reserved_special_token_44|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128050": {
+      "content": "<|reserved_special_token_45|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128051": {
+      "content": "<|reserved_special_token_46|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128052": {
+      "content": "<|reserved_special_token_47|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128053": {
+      "content": "<|reserved_special_token_48|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128054": {
+      "content": "<|reserved_special_token_49|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128055": {
+      "content": "<|reserved_special_token_50|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128056": {
+      "content": "<|reserved_special_token_51|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128057": {
+      "content": "<|reserved_special_token_52|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128058": {
+      "content": "<|reserved_special_token_53|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128059": {
+      "content": "<|reserved_special_token_54|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128060": {
+      "content": "<|reserved_special_token_55|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128061": {
+      "content": "<|reserved_special_token_56|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128062": {
+      "content": "<|reserved_special_token_57|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128063": {
+      "content": "<|reserved_special_token_58|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128064": {
+      "content": "<|reserved_special_token_59|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128065": {
+      "content": "<|reserved_special_token_60|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128066": {
+      "content": "<|reserved_special_token_61|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128067": {
+      "content": "<|reserved_special_token_62|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128068": {
+      "content": "<|reserved_special_token_63|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128069": {
+      "content": "<|reserved_special_token_64|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128070": {
+      "content": "<|reserved_special_token_65|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128071": {
+      "content": "<|reserved_special_token_66|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128072": {
+      "content": "<|reserved_special_token_67|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128073": {
+      "content": "<|reserved_special_token_68|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128074": {
+      "content": "<|reserved_special_token_69|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128075": {
+      "content": "<|reserved_special_token_70|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128076": {
+      "content": "<|reserved_special_token_71|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128077": {
+      "content": "<|reserved_special_token_72|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128078": {
+      "content": "<|reserved_special_token_73|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128079": {
+      "content": "<|reserved_special_token_74|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128080": {
+      "content": "<|reserved_special_token_75|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128081": {
+      "content": "<|reserved_special_token_76|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128082": {
+      "content": "<|reserved_special_token_77|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128083": {
+      "content": "<|reserved_special_token_78|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128084": {
+      "content": "<|reserved_special_token_79|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128085": {
+      "content": "<|reserved_special_token_80|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128086": {
+      "content": "<|reserved_special_token_81|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128087": {
+      "content": "<|reserved_special_token_82|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128088": {
+      "content": "<|reserved_special_token_83|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128089": {
+      "content": "<|reserved_special_token_84|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128090": {
+      "content": "<|reserved_special_token_85|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128091": {
+      "content": "<|reserved_special_token_86|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128092": {
+      "content": "<|reserved_special_token_87|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128093": {
+      "content": "<|reserved_special_token_88|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128094": {
+      "content": "<|reserved_special_token_89|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128095": {
+      "content": "<|reserved_special_token_90|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128096": {
+      "content": "<|reserved_special_token_91|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128097": {
+      "content": "<|reserved_special_token_92|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128098": {
+      "content": "<|reserved_special_token_93|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128099": {
+      "content": "<|reserved_special_token_94|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128100": {
+      "content": "<|reserved_special_token_95|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128101": {
+      "content": "<|reserved_special_token_96|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128102": {
+      "content": "<|reserved_special_token_97|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128103": {
+      "content": "<|reserved_special_token_98|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128104": {
+      "content": "<|reserved_special_token_99|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128105": {
+      "content": "<|reserved_special_token_100|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128106": {
+      "content": "<|reserved_special_token_101|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128107": {
+      "content": "<|reserved_special_token_102|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128108": {
+      "content": "<|reserved_special_token_103|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128109": {
+      "content": "<|reserved_special_token_104|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128110": {
+      "content": "<|reserved_special_token_105|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128111": {
+      "content": "<|reserved_special_token_106|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128112": {
+      "content": "<|reserved_special_token_107|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128113": {
+      "content": "<|reserved_special_token_108|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128114": {
+      "content": "<|reserved_special_token_109|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128115": {
+      "content": "<|reserved_special_token_110|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128116": {
+      "content": "<|reserved_special_token_111|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128117": {
+      "content": "<|reserved_special_token_112|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128118": {
+      "content": "<|reserved_special_token_113|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128119": {
+      "content": "<|reserved_special_token_114|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128120": {
+      "content": "<|reserved_special_token_115|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128121": {
+      "content": "<|reserved_special_token_116|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128122": {
+      "content": "<|reserved_special_token_117|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128123": {
+      "content": "<|reserved_special_token_118|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128124": {
+      "content": "<|reserved_special_token_119|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128125": {
+      "content": "<|reserved_special_token_120|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128126": {
+      "content": "<|reserved_special_token_121|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128127": {
+      "content": "<|reserved_special_token_122|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128128": {
+      "content": "<|reserved_special_token_123|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128129": {
+      "content": "<|reserved_special_token_124|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128130": {
+      "content": "<|reserved_special_token_125|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128131": {
+      "content": "<|reserved_special_token_126|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128132": {
+      "content": "<|reserved_special_token_127|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128133": {
+      "content": "<|reserved_special_token_128|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128134": {
+      "content": "<|reserved_special_token_129|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128135": {
+      "content": "<|reserved_special_token_130|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128136": {
+      "content": "<|reserved_special_token_131|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128137": {
+      "content": "<|reserved_special_token_132|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128138": {
+      "content": "<|reserved_special_token_133|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128139": {
+      "content": "<|reserved_special_token_134|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128140": {
+      "content": "<|reserved_special_token_135|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128141": {
+      "content": "<|reserved_special_token_136|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128142": {
+      "content": "<|reserved_special_token_137|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128143": {
+      "content": "<|reserved_special_token_138|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128144": {
+      "content": "<|reserved_special_token_139|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128145": {
+      "content": "<|reserved_special_token_140|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128146": {
+      "content": "<|reserved_special_token_141|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128147": {
+      "content": "<|reserved_special_token_142|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128148": {
+      "content": "<|reserved_special_token_143|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128149": {
+      "content": "<|reserved_special_token_144|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128150": {
+      "content": "<|reserved_special_token_145|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128151": {
+      "content": "<|reserved_special_token_146|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128152": {
+      "content": "<|reserved_special_token_147|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128153": {
+      "content": "<|reserved_special_token_148|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128154": {
+      "content": "<|reserved_special_token_149|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128155": {
+      "content": "<|reserved_special_token_150|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128156": {
+      "content": "<|reserved_special_token_151|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128157": {
+      "content": "<|reserved_special_token_152|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128158": {
+      "content": "<|reserved_special_token_153|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128159": {
+      "content": "<|reserved_special_token_154|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128160": {
+      "content": "<|reserved_special_token_155|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128161": {
+      "content": "<|reserved_special_token_156|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128162": {
+      "content": "<|reserved_special_token_157|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128163": {
+      "content": "<|reserved_special_token_158|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128164": {
+      "content": "<|reserved_special_token_159|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128165": {
+      "content": "<|reserved_special_token_160|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128166": {
+      "content": "<|reserved_special_token_161|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128167": {
+      "content": "<|reserved_special_token_162|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128168": {
+      "content": "<|reserved_special_token_163|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128169": {
+      "content": "<|reserved_special_token_164|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128170": {
+      "content": "<|reserved_special_token_165|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128171": {
+      "content": "<|reserved_special_token_166|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128172": {
+      "content": "<|reserved_special_token_167|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128173": {
+      "content": "<|reserved_special_token_168|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128174": {
+      "content": "<|reserved_special_token_169|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128175": {
+      "content": "<|reserved_special_token_170|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128176": {
+      "content": "<|reserved_special_token_171|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128177": {
+      "content": "<|reserved_special_token_172|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128178": {
+      "content": "<|reserved_special_token_173|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128179": {
+      "content": "<|reserved_special_token_174|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128180": {
+      "content": "<|reserved_special_token_175|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128181": {
+      "content": "<|reserved_special_token_176|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128182": {
+      "content": "<|reserved_special_token_177|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128183": {
+      "content": "<|reserved_special_token_178|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128184": {
+      "content": "<|reserved_special_token_179|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128185": {
+      "content": "<|reserved_special_token_180|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128186": {
+      "content": "<|reserved_special_token_181|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128187": {
+      "content": "<|reserved_special_token_182|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128188": {
+      "content": "<|reserved_special_token_183|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128189": {
+      "content": "<|reserved_special_token_184|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128190": {
+      "content": "<|reserved_special_token_185|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128191": {
+      "content": "<|reserved_special_token_186|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128192": {
+      "content": "<|reserved_special_token_187|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128193": {
+      "content": "<|reserved_special_token_188|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128194": {
+      "content": "<|reserved_special_token_189|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128195": {
+      "content": "<|reserved_special_token_190|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128196": {
+      "content": "<|reserved_special_token_191|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128197": {
+      "content": "<|reserved_special_token_192|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128198": {
+      "content": "<|reserved_special_token_193|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128199": {
+      "content": "<|reserved_special_token_194|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128200": {
+      "content": "<|reserved_special_token_195|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128201": {
+      "content": "<|reserved_special_token_196|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128202": {
+      "content": "<|reserved_special_token_197|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128203": {
+      "content": "<|reserved_special_token_198|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128204": {
+      "content": "<|reserved_special_token_199|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128205": {
+      "content": "<|reserved_special_token_200|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128206": {
+      "content": "<|reserved_special_token_201|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128207": {
+      "content": "<|reserved_special_token_202|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128208": {
+      "content": "<|reserved_special_token_203|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128209": {
+      "content": "<|reserved_special_token_204|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128210": {
+      "content": "<|reserved_special_token_205|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128211": {
+      "content": "<|reserved_special_token_206|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128212": {
+      "content": "<|reserved_special_token_207|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128213": {
+      "content": "<|reserved_special_token_208|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128214": {
+      "content": "<|reserved_special_token_209|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128215": {
+      "content": "<|reserved_special_token_210|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128216": {
+      "content": "<|reserved_special_token_211|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128217": {
+      "content": "<|reserved_special_token_212|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128218": {
+      "content": "<|reserved_special_token_213|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128219": {
+      "content": "<|reserved_special_token_214|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128220": {
+      "content": "<|reserved_special_token_215|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128221": {
+      "content": "<|reserved_special_token_216|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128222": {
+      "content": "<|reserved_special_token_217|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128223": {
+      "content": "<|reserved_special_token_218|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128224": {
+      "content": "<|reserved_special_token_219|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128225": {
+      "content": "<|reserved_special_token_220|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128226": {
+      "content": "<|reserved_special_token_221|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128227": {
+      "content": "<|reserved_special_token_222|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128228": {
+      "content": "<|reserved_special_token_223|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128229": {
+      "content": "<|reserved_special_token_224|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128230": {
+      "content": "<|reserved_special_token_225|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128231": {
+      "content": "<|reserved_special_token_226|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128232": {
+      "content": "<|reserved_special_token_227|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128233": {
+      "content": "<|reserved_special_token_228|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128234": {
+      "content": "<|reserved_special_token_229|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128235": {
+      "content": "<|reserved_special_token_230|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128236": {
+      "content": "<|reserved_special_token_231|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128237": {
+      "content": "<|reserved_special_token_232|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128238": {
+      "content": "<|reserved_special_token_233|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128239": {
+      "content": "<|reserved_special_token_234|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128240": {
+      "content": "<|reserved_special_token_235|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128241": {
+      "content": "<|reserved_special_token_236|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128242": {
+      "content": "<|reserved_special_token_237|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128243": {
+      "content": "<|reserved_special_token_238|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128244": {
+      "content": "<|reserved_special_token_239|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128245": {
+      "content": "<|reserved_special_token_240|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128246": {
+      "content": "<|reserved_special_token_241|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128247": {
+      "content": "<|reserved_special_token_242|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128248": {
+      "content": "<|reserved_special_token_243|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128249": {
+      "content": "<|reserved_special_token_244|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128250": {
+      "content": "<|reserved_special_token_245|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128251": {
+      "content": "<|reserved_special_token_246|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128252": {
+      "content": "<|reserved_special_token_247|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128253": {
+      "content": "<|reserved_special_token_248|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128254": {
+      "content": "<|reserved_special_token_249|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128255": {
+      "content": "<|reserved_special_token_250|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<|begin_of_text|>",
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "<|eot_id|>",
+  "extra_special_tokens": {},
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1024,
+  "pad_token": "<|eot_id|>",
+  "padding_side": "left",
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "truncation_side": "left"
+}

checkpoints/archer_Llama3-8B-I_word/README.md

@@ -0,0 +1,207 @@
+---
+base_model: /home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_word/merged_model
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:/home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_word/merged_model
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.17.1

checkpoints/archer_Llama3-8B-I_word/adapter_config.json

@@ -0,0 +1,37 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "/home/jiashuo/codes/ForesightOptim/checkpoints/im_Llama3-8B-I_word/merged_model",
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "qalora_group_size": 16,
+  "r": 8,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "v_proj",
+    "q_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

checkpoints/archer_Llama3-8B-I_word/adapter_model.safetensors

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

checkpoints/archer_Llama3-8B-I_word/chat_template.jinja

@@ -0,0 +1,5 @@
+{% set loop_messages = messages %}{% for message in loop_messages %}{% set content = '<|start_header_id|>' + message['role'] + '<|end_header_id|>
+
+'+ message['content'] | trim + '<|eot_id|>' %}{% if loop.index0 == 0 %}{% set content = bos_token + content %}{% endif %}{{ content }}{% endfor %}{% if add_generation_prompt %}{{ '<|start_header_id|>assistant<|end_header_id|>
+
+' }}{% endif %}

checkpoints/archer_Llama3-8B-I_word/special_tokens_map.json

@@ -0,0 +1,23 @@
+{
+  "bos_token": {
+    "content": "<|begin_of_text|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|eot_id|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|eot_id|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

checkpoints/archer_Llama3-8B-I_word/tokenizer.json

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

checkpoints/archer_Llama3-8B-I_word/tokenizer_config.json

@@ -0,0 +1,2065 @@
+{
+  "added_tokens_decoder": {
+    "128000": {
+      "content": "<|begin_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128001": {
+      "content": "<|end_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128002": {
+      "content": "<|reserved_special_token_0|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128003": {
+      "content": "<|reserved_special_token_1|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128004": {
+      "content": "<|reserved_special_token_2|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128005": {
+      "content": "<|reserved_special_token_3|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128006": {
+      "content": "<|start_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128007": {
+      "content": "<|end_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128008": {
+      "content": "<|reserved_special_token_4|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128009": {
+      "content": "<|eot_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128010": {
+      "content": "<|reserved_special_token_5|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128011": {
+      "content": "<|reserved_special_token_6|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128012": {
+      "content": "<|reserved_special_token_7|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128013": {
+      "content": "<|reserved_special_token_8|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128014": {
+      "content": "<|reserved_special_token_9|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128015": {
+      "content": "<|reserved_special_token_10|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128016": {
+      "content": "<|reserved_special_token_11|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128017": {
+      "content": "<|reserved_special_token_12|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128018": {
+      "content": "<|reserved_special_token_13|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128019": {
+      "content": "<|reserved_special_token_14|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128020": {
+      "content": "<|reserved_special_token_15|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128021": {
+      "content": "<|reserved_special_token_16|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128022": {
+      "content": "<|reserved_special_token_17|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128023": {
+      "content": "<|reserved_special_token_18|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128024": {
+      "content": "<|reserved_special_token_19|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128025": {
+      "content": "<|reserved_special_token_20|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128026": {
+      "content": "<|reserved_special_token_21|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128027": {
+      "content": "<|reserved_special_token_22|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128028": {
+      "content": "<|reserved_special_token_23|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128029": {
+      "content": "<|reserved_special_token_24|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128030": {
+      "content": "<|reserved_special_token_25|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128031": {
+      "content": "<|reserved_special_token_26|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128032": {
+      "content": "<|reserved_special_token_27|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128033": {
+      "content": "<|reserved_special_token_28|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128034": {
+      "content": "<|reserved_special_token_29|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128035": {
+      "content": "<|reserved_special_token_30|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128036": {
+      "content": "<|reserved_special_token_31|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128037": {
+      "content": "<|reserved_special_token_32|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128038": {
+      "content": "<|reserved_special_token_33|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128039": {
+      "content": "<|reserved_special_token_34|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128040": {
+      "content": "<|reserved_special_token_35|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128041": {
+      "content": "<|reserved_special_token_36|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128042": {
+      "content": "<|reserved_special_token_37|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128043": {
+      "content": "<|reserved_special_token_38|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128044": {
+      "content": "<|reserved_special_token_39|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128045": {
+      "content": "<|reserved_special_token_40|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128046": {
+      "content": "<|reserved_special_token_41|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128047": {
+      "content": "<|reserved_special_token_42|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128048": {
+      "content": "<|reserved_special_token_43|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128049": {
+      "content": "<|reserved_special_token_44|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128050": {
+      "content": "<|reserved_special_token_45|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128051": {
+      "content": "<|reserved_special_token_46|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128052": {
+      "content": "<|reserved_special_token_47|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128053": {
+      "content": "<|reserved_special_token_48|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128054": {
+      "content": "<|reserved_special_token_49|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128055": {
+      "content": "<|reserved_special_token_50|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128056": {
+      "content": "<|reserved_special_token_51|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128057": {
+      "content": "<|reserved_special_token_52|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128058": {
+      "content": "<|reserved_special_token_53|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128059": {
+      "content": "<|reserved_special_token_54|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128060": {
+      "content": "<|reserved_special_token_55|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128061": {
+      "content": "<|reserved_special_token_56|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128062": {
+      "content": "<|reserved_special_token_57|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128063": {
+      "content": "<|reserved_special_token_58|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128064": {
+      "content": "<|reserved_special_token_59|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128065": {
+      "content": "<|reserved_special_token_60|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128066": {
+      "content": "<|reserved_special_token_61|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128067": {
+      "content": "<|reserved_special_token_62|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128068": {
+      "content": "<|reserved_special_token_63|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128069": {
+      "content": "<|reserved_special_token_64|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128070": {
+      "content": "<|reserved_special_token_65|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128071": {
+      "content": "<|reserved_special_token_66|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128072": {
+      "content": "<|reserved_special_token_67|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128073": {
+      "content": "<|reserved_special_token_68|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128074": {
+      "content": "<|reserved_special_token_69|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128075": {
+      "content": "<|reserved_special_token_70|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128076": {
+      "content": "<|reserved_special_token_71|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128077": {
+      "content": "<|reserved_special_token_72|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128078": {
+      "content": "<|reserved_special_token_73|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128079": {
+      "content": "<|reserved_special_token_74|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128080": {
+      "content": "<|reserved_special_token_75|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128081": {
+      "content": "<|reserved_special_token_76|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128082": {
+      "content": "<|reserved_special_token_77|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128083": {
+      "content": "<|reserved_special_token_78|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128084": {
+      "content": "<|reserved_special_token_79|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128085": {
+      "content": "<|reserved_special_token_80|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128086": {
+      "content": "<|reserved_special_token_81|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128087": {
+      "content": "<|reserved_special_token_82|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128088": {
+      "content": "<|reserved_special_token_83|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128089": {
+      "content": "<|reserved_special_token_84|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128090": {
+      "content": "<|reserved_special_token_85|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128091": {
+      "content": "<|reserved_special_token_86|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128092": {
+      "content": "<|reserved_special_token_87|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128093": {
+      "content": "<|reserved_special_token_88|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128094": {
+      "content": "<|reserved_special_token_89|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128095": {
+      "content": "<|reserved_special_token_90|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128096": {
+      "content": "<|reserved_special_token_91|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128097": {
+      "content": "<|reserved_special_token_92|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128098": {
+      "content": "<|reserved_special_token_93|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128099": {
+      "content": "<|reserved_special_token_94|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128100": {
+      "content": "<|reserved_special_token_95|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128101": {
+      "content": "<|reserved_special_token_96|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128102": {
+      "content": "<|reserved_special_token_97|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128103": {
+      "content": "<|reserved_special_token_98|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128104": {
+      "content": "<|reserved_special_token_99|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128105": {
+      "content": "<|reserved_special_token_100|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128106": {
+      "content": "<|reserved_special_token_101|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128107": {
+      "content": "<|reserved_special_token_102|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128108": {
+      "content": "<|reserved_special_token_103|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128109": {
+      "content": "<|reserved_special_token_104|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128110": {
+      "content": "<|reserved_special_token_105|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128111": {
+      "content": "<|reserved_special_token_106|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128112": {
+      "content": "<|reserved_special_token_107|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128113": {
+      "content": "<|reserved_special_token_108|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128114": {
+      "content": "<|reserved_special_token_109|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128115": {
+      "content": "<|reserved_special_token_110|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128116": {
+      "content": "<|reserved_special_token_111|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128117": {
+      "content": "<|reserved_special_token_112|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128118": {
+      "content": "<|reserved_special_token_113|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128119": {
+      "content": "<|reserved_special_token_114|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128120": {
+      "content": "<|reserved_special_token_115|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128121": {
+      "content": "<|reserved_special_token_116|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128122": {
+      "content": "<|reserved_special_token_117|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128123": {
+      "content": "<|reserved_special_token_118|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128124": {
+      "content": "<|reserved_special_token_119|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128125": {
+      "content": "<|reserved_special_token_120|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128126": {
+      "content": "<|reserved_special_token_121|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128127": {
+      "content": "<|reserved_special_token_122|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128128": {
+      "content": "<|reserved_special_token_123|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128129": {
+      "content": "<|reserved_special_token_124|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128130": {
+      "content": "<|reserved_special_token_125|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128131": {
+      "content": "<|reserved_special_token_126|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128132": {
+      "content": "<|reserved_special_token_127|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128133": {
+      "content": "<|reserved_special_token_128|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128134": {
+      "content": "<|reserved_special_token_129|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128135": {
+      "content": "<|reserved_special_token_130|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128136": {
+      "content": "<|reserved_special_token_131|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128137": {
+      "content": "<|reserved_special_token_132|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128138": {
+      "content": "<|reserved_special_token_133|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128139": {
+      "content": "<|reserved_special_token_134|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128140": {
+      "content": "<|reserved_special_token_135|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128141": {
+      "content": "<|reserved_special_token_136|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128142": {
+      "content": "<|reserved_special_token_137|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128143": {
+      "content": "<|reserved_special_token_138|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128144": {
+      "content": "<|reserved_special_token_139|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128145": {
+      "content": "<|reserved_special_token_140|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128146": {
+      "content": "<|reserved_special_token_141|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128147": {
+      "content": "<|reserved_special_token_142|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128148": {
+      "content": "<|reserved_special_token_143|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128149": {
+      "content": "<|reserved_special_token_144|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128150": {
+      "content": "<|reserved_special_token_145|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128151": {
+      "content": "<|reserved_special_token_146|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128152": {
+      "content": "<|reserved_special_token_147|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128153": {
+      "content": "<|reserved_special_token_148|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128154": {
+      "content": "<|reserved_special_token_149|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128155": {
+      "content": "<|reserved_special_token_150|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128156": {
+      "content": "<|reserved_special_token_151|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128157": {
+      "content": "<|reserved_special_token_152|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128158": {
+      "content": "<|reserved_special_token_153|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128159": {
+      "content": "<|reserved_special_token_154|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128160": {
+      "content": "<|reserved_special_token_155|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128161": {
+      "content": "<|reserved_special_token_156|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128162": {
+      "content": "<|reserved_special_token_157|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128163": {
+      "content": "<|reserved_special_token_158|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128164": {
+      "content": "<|reserved_special_token_159|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128165": {
+      "content": "<|reserved_special_token_160|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128166": {
+      "content": "<|reserved_special_token_161|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128167": {
+      "content": "<|reserved_special_token_162|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128168": {
+      "content": "<|reserved_special_token_163|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128169": {
+      "content": "<|reserved_special_token_164|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128170": {
+      "content": "<|reserved_special_token_165|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128171": {
+      "content": "<|reserved_special_token_166|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128172": {
+      "content": "<|reserved_special_token_167|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128173": {
+      "content": "<|reserved_special_token_168|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128174": {
+      "content": "<|reserved_special_token_169|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128175": {
+      "content": "<|reserved_special_token_170|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128176": {
+      "content": "<|reserved_special_token_171|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128177": {
+      "content": "<|reserved_special_token_172|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128178": {
+      "content": "<|reserved_special_token_173|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128179": {
+      "content": "<|reserved_special_token_174|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128180": {
+      "content": "<|reserved_special_token_175|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128181": {
+      "content": "<|reserved_special_token_176|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128182": {
+      "content": "<|reserved_special_token_177|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128183": {
+      "content": "<|reserved_special_token_178|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128184": {
+      "content": "<|reserved_special_token_179|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128185": {
+      "content": "<|reserved_special_token_180|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128186": {
+      "content": "<|reserved_special_token_181|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128187": {
+      "content": "<|reserved_special_token_182|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128188": {
+      "content": "<|reserved_special_token_183|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128189": {
+      "content": "<|reserved_special_token_184|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128190": {
+      "content": "<|reserved_special_token_185|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128191": {
+      "content": "<|reserved_special_token_186|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128192": {
+      "content": "<|reserved_special_token_187|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128193": {
+      "content": "<|reserved_special_token_188|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128194": {
+      "content": "<|reserved_special_token_189|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128195": {
+      "content": "<|reserved_special_token_190|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128196": {
+      "content": "<|reserved_special_token_191|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128197": {
+      "content": "<|reserved_special_token_192|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128198": {
+      "content": "<|reserved_special_token_193|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128199": {
+      "content": "<|reserved_special_token_194|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128200": {
+      "content": "<|reserved_special_token_195|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128201": {
+      "content": "<|reserved_special_token_196|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128202": {
+      "content": "<|reserved_special_token_197|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128203": {
+      "content": "<|reserved_special_token_198|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128204": {
+      "content": "<|reserved_special_token_199|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128205": {
+      "content": "<|reserved_special_token_200|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128206": {
+      "content": "<|reserved_special_token_201|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128207": {
+      "content": "<|reserved_special_token_202|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128208": {
+      "content": "<|reserved_special_token_203|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128209": {
+      "content": "<|reserved_special_token_204|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128210": {
+      "content": "<|reserved_special_token_205|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128211": {
+      "content": "<|reserved_special_token_206|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128212": {
+      "content": "<|reserved_special_token_207|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128213": {
+      "content": "<|reserved_special_token_208|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128214": {
+      "content": "<|reserved_special_token_209|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128215": {
+      "content": "<|reserved_special_token_210|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128216": {
+      "content": "<|reserved_special_token_211|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128217": {
+      "content": "<|reserved_special_token_212|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128218": {
+      "content": "<|reserved_special_token_213|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128219": {
+      "content": "<|reserved_special_token_214|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128220": {
+      "content": "<|reserved_special_token_215|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128221": {
+      "content": "<|reserved_special_token_216|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128222": {
+      "content": "<|reserved_special_token_217|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128223": {
+      "content": "<|reserved_special_token_218|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128224": {
+      "content": "<|reserved_special_token_219|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128225": {
+      "content": "<|reserved_special_token_220|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128226": {
+      "content": "<|reserved_special_token_221|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128227": {
+      "content": "<|reserved_special_token_222|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128228": {
+      "content": "<|reserved_special_token_223|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128229": {
+      "content": "<|reserved_special_token_224|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128230": {
+      "content": "<|reserved_special_token_225|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128231": {
+      "content": "<|reserved_special_token_226|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128232": {
+      "content": "<|reserved_special_token_227|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128233": {
+      "content": "<|reserved_special_token_228|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128234": {
+      "content": "<|reserved_special_token_229|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128235": {
+      "content": "<|reserved_special_token_230|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128236": {
+      "content": "<|reserved_special_token_231|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128237": {
+      "content": "<|reserved_special_token_232|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128238": {
+      "content": "<|reserved_special_token_233|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128239": {
+      "content": "<|reserved_special_token_234|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128240": {
+      "content": "<|reserved_special_token_235|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128241": {
+      "content": "<|reserved_special_token_236|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128242": {
+      "content": "<|reserved_special_token_237|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128243": {
+      "content": "<|reserved_special_token_238|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128244": {
+      "content": "<|reserved_special_token_239|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128245": {
+      "content": "<|reserved_special_token_240|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128246": {
+      "content": "<|reserved_special_token_241|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128247": {
+      "content": "<|reserved_special_token_242|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128248": {
+      "content": "<|reserved_special_token_243|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128249": {
+      "content": "<|reserved_special_token_244|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128250": {
+      "content": "<|reserved_special_token_245|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128251": {
+      "content": "<|reserved_special_token_246|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128252": {
+      "content": "<|reserved_special_token_247|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128253": {
+      "content": "<|reserved_special_token_248|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128254": {
+      "content": "<|reserved_special_token_249|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128255": {
+      "content": "<|reserved_special_token_250|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<|begin_of_text|>",
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "<|eot_id|>",
+  "extra_special_tokens": {},
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1024,
+  "pad_token": "<|eot_id|>",
+  "padding_side": "left",
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "truncation_side": "left"
+}

deepspeed_zero3.yaml

@@ -0,0 +1,66 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  zero3_save_16bit_model: true
+  zero_optimization:
+    stage: 3
+    offload_optimizer:
+      device: cpu
+      pin_memory: true
+      buffer_count: 4
+    offload_param:
+      device: cpu
+      pin_memory: true
+      buffer_count: 4
+    model_parallel:
+      enable: true
+      tensor_parallel_size: 4
+      pipeline_parallel_size: 1
+    reduce_bucket_size: 2e5
+    stage3_prefetch_bucket_size: 0.1e6  # Reduced further
+    stage3_max_live_parameters: 1e6
+    stage3_max_reuse_distance: 1e5
+    stage3_max_live_gradients: 1e6
+    stage3_param_persistence_threshold: 1e4
+    sub_group_size: 1e9
+  
+  activation_checkpointing:
+    partition_activations: true
+    contiguous_memory_optimization: true
+    cpu_checkpointing: true
+  
+  bf16:
+    enabled: false
+  fp16:
+    enabled: true
+
+  optimizer:
+    type: AdamW
+    params:
+      eight_bit: true
+      lr: auto
+      betas: auto
+      eps: auto
+      weight_decay: auto
+  
+  scheduler:
+    type: WarmupDecayLR
+    params:
+      num_warmup_steps: auto
+      num_training_steps: auto
+
+  communication_data_type: fp16
+  communication_bucket_size: 500000000
+  dist_backend: nccl
+  train_micro_batch_size_per_gpu: auto
+  gradient_clipping: 1.0
+
+distributed_type: DEEPSPEED
+downcast_bf16: auto
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+rdzv_backend: static
+same_network: true
+use_cpu: auto

main.py

@@ -0,0 +1,33 @@
+# main.py
+from lightning.pytorch.cli import LightningCLI
+from lightning.pytorch.callbacks import ModelCheckpoint
+from lightning.fabric import seed_everything
+from Algorithms import ActorCritic
+from Tasks import TwentyQuestions
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True  # 启用 TF32 加速
+torch.backends.cudnn.allow_tf32 = True
+from torch.cuda.amp import GradScaler  # 如果用 AMP
+
+seed_everything(42)
+
+def cli_main():
+    checkpoint_callback = ModelCheckpoint(
+        dirpath="models",
+        every_n_train_steps=200,
+        every_n_epochs=0,
+        save_top_k=1,
+        save_last=True            # 同时保存最后一个模型
+    )
+    cli = LightningCLI(
+        save_config_kwargs={"overwrite": True},
+        trainer_defaults={  # 添加 trainer 默认配置
+            "callbacks": [checkpoint_callback],
+            "limit_val_batches": 0,
+            "val_check_interval": None
+        }
+    )
+    exit(0)
+
+if __name__ == "__main__":
+    cli_main()

requirements.txt

@@ -0,0 +1,13 @@
+lightning
+jsonargparse
+lightning-utilities
+numpy
+pytorch-lightning
+safetensors
+sentencepiece
+torch
+torchmetrics
+tqdm
+transformers
+wandb
+jsonargparse[signatures]>=4.26.1

rsa_game.py

@@ -0,0 +1,383 @@
+import re
+import string
+import random
+from typing import Optional, Tuple, List, Dict
+from nltk.stem import PorterStemmer
+PSTEMMER = PorterStemmer()
+        
+GAME_RULE_PROMPTS = [
+    """Play the game of Collabrative Rational Speech Act Game. In this game, there are two players, a speaker and a listener.
+
+At the beginning, the speaker is assigned a target object, with which the listener is not informed. The task of the speaker is to guide the listener to guess the target object, then they win the game. However, the speaker is only allowed to give one feature per turn.
+
+At the same time, the listener tries to figure out the target object and give the possible target referent objects at each turn. The listener can give more than one possible target referent object sets at each turn. If the listener identifies the target object, he can say "I know the target object! It is `target object`!".
+
+At each turn, the speaker should try to give a feature of the target object which provides the listener with the most information, and the listener would update the possible target referent objects from the previous turn.
+
+Remember, the listener can only update his referent set from the previous turn's guess, he cannot add new referents.
+
+The less turns they take to guess the target object, the higher the score they get.
+""",
+    """Engage in the collaborative challenge of Rational Speech Act Game, featuring two participants: one takes on the role of the speaker, while the other serves as the listener.
+
+Initially, the speaker is secretly assigned a target object, which remains unknown to the listener. The speaker's objective is to strategically guide the listener toward identifying the target object, thereby securing victory. However, there's a constraint: the speaker may only provide one feature per turn.
+
+Simultaneously, the listener's mission is to deduce the target object and present possible target referent objects at each turn. The listener has the flexibility to offer multiple possible target referent object sets during their turn. If the listener identifies the target object, they can declare "I know the target object! It is `target object`!".
+
+During each turn, the speaker should aim to provide a feature of the target object that maximizes the information available to the listener, while the listener updates their possible target referent objects based on the previous turn's information.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring system rewards efficiency: fewer turns required to guess the target object results in higher scores.
+""",
+    """Dive into the strategic collaboration known as Rational Speech Act Game, where two players assume distinct roles: the speaker and the listener.
+
+To commence the game, the speaker receives a target object in secret, while the listener remains unaware of this object. The speaker's challenge is to effectively guide the listener toward correctly identifying the target object, which would result in a win. However, there's a limitation: the speaker can only share one feature per turn.
+
+Concurrently, the listener embarks on a quest to determine the target object and must present possible target referent objects at each turn. The listener enjoys the advantage of being able to propose multiple possible target referent object sets during their turn. If the listener identifies the target object, they can proclaim "I know the target object! It is `target object`!".
+
+At each turn, the speaker should strategically select a feature of the target object that provides the listener with maximum informational value, while the listener refines their possible target referent objects based on the previous turn's revelations.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring mechanism emphasizes efficiency: achieving the target object identification in fewer turns yields higher scores.
+""",
+    """Step into the cooperative challenge of Rational Speech Act Game, a game designed for two players: one acting as the speaker, the other as the listener.
+
+In the opening phase, the speaker is discreetly given a target object, which is kept hidden from the listener. The speaker's goal is to successfully lead the listener to identify the target object, thereby claiming victory. However, there's a rule: the speaker is restricted to providing only one feature per turn.
+
+At the same time, the listener's task is to figure out the target object and present possible target referent objects at each turn. The listener has the liberty to suggest multiple possible target referent object sets during their turn. If the listener identifies the target object, they can announce "I know the target object! It is `target object`!".
+
+During each turn, the speaker should carefully choose a feature of the target object that delivers the most valuable information to the listener, while the listener adjusts their possible target referent objects based on the previous turn's insights.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring system prioritizes efficiency: the fewer turns taken to identify the target object, the higher the score achieved.
+""",
+    """Immerse yourself in the collaborative strategy game called Rational Speech Act Game, featuring two distinct roles: the speaker and the listener.
+
+As the game begins, the speaker is covertly assigned a target object, which remains a mystery to the listener. The speaker's mission is to skillfully guide the listener toward correctly identifying the target object, which would secure a win. However, there's a restriction: the speaker may only offer one feature per turn.
+
+Meanwhile, the listener is engaged in a process of deduction, attempting to determine the target object and presenting possible target referent objects at each turn. The listener benefits from the ability to suggest multiple possible target referent object sets during their turn. If the listener identifies the target object, they can state "I know the target object! It is `target object`!".
+
+At each turn, the speaker should strategically provide a feature of the target object that maximizes the informational benefit for the listener, while the listener updates their possible target referent objects based on the previous turn's information.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring framework rewards efficiency: fewer turns required to identify the target object results in higher scores.
+""",
+    """Dive into the collaborative challenge known as Rational Speech Act Game, where two players take on specific roles: the speaker and the listener.
+
+The speaker starts the game with a secret target object assignment, while the listener remains in the dark about this object. The speaker's objective is to effectively guide the listener toward identifying the target object, thereby achieving victory. However, there's a constraint: the speaker can only provide one feature per turn.
+
+Concurrently, the listener's challenge is to deduce the target object and present possible target referent objects at each turn. The listener enjoys the flexibility of being able to suggest multiple possible target referent object sets during their turn. If the listener identifies the target object, they can express "I know the target object! It is `target object`!".
+
+During each turn, the speaker should aim to provide a feature of the target object that offers the listener the most valuable information, while the listener refines their possible target referent objects based on the previous turn's revelations.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring mechanism emphasizes efficiency: achieving target object identification in fewer turns yields higher scores.
+""",
+    """Step into the strategic collaboration called Rational Speech Act Game, where the roles of speaker and listener are central to the gameplay.
+
+The speaker embarks on this journey with a secretly assigned target object, while the listener begins unaware of this object. The speaker's challenge is to successfully guide the listener toward identifying the target object, which would result in a win. However, there's a limitation: the speaker is only permitted to share one feature per turn.
+
+On the other side, the listener's mission is to figure out the target object and present possible target referent objects at each turn. The listener has the advantage of being able to propose multiple possible target referent object sets during their turn. If the listener identifies the target object, they can reveal "I know the target object! It is `target object`!".
+
+At each turn, the speaker should strategically select a feature of the target object that provides the listener with maximum informational value, while the listener updates their possible target referent objects based on the previous turn's insights.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring system prioritizes efficiency: fewer turns taken to identify the target object results in higher scores.
+""",
+    """Embark on the collaborative challenge of Rational Speech Act Game, where players assume the roles of either speaker or listener.
+
+The speaker enters the game with a covertly assigned target object, while the listener starts without knowledge of this object. The speaker's goal is to effectively guide the listener toward identifying the target object, thereby securing victory. However, there's a rule: the speaker may only provide one feature per turn.
+
+Simultaneously, the listener's task is to deduce the target object and present possible target referent objects at each turn. The listener benefits from the ability to suggest multiple possible target referent object sets during their turn. If the listener identifies the target object, they can declare "I know the target object! It is `target object`!".
+
+During each turn, the speaker should carefully choose a feature of the target object that delivers the most valuable information to the listener, while the listener adjusts their possible target referent objects based on the previous turn's information.
+
+Remember, the listener can only update their referent set from the previous turn's guess; they cannot add new referents.
+
+The scoring framework rewards efficiency: the fewer turns required to identify the target object, the higher the score achieved.
+""",
+]
+
+
+INSTRUCT_PROMPTS = {
+    "speaker": """\n\n### Instruction: You are the pragmatic rational speaker. The target object is `{target}` and the object list is '{object_list}'. Provide your response including the object feature.\n\n### Response:""",
+    "listener": """\n\n### Instruction: Your are the pragmatic rational listener. The object list is '{object_list}'. Provide your infered target object or the possible target object sets.\n\n### Response:""",
+}
+
+PLAYER_INSTRUCT_PROMPTS = {
+    "speaker": "You are the pragmatic rational speaker. The target object is `{target}` and the object list is '{object_list}'. Provide your response including the object feature.",
+    "listener": "Your are the pragmatic rational listener. The object list is '{object_list}'. Provide your infered target object or the possible target object sets.",
+}
+
+ROLES = ["speaker", "listener"]
+PREDICT_TEMP = r"i know the target object"
+
+def calculate_reward(turn, golden_turn):
+    if turn <= golden_turn:
+        return 1
+    else:
+        return 0
+
+
+def get_object_list(formatted_str):
+    """Reverse the item_string function to extract the original list of items"""
+    # If the string is empty, return empty list
+    if not formatted_str:
+        return []
+
+    # Remove surrounding brackets/parentheses/braces if present
+    if formatted_str.startswith("[") and formatted_str.endswith("]"):
+        formatted_str = formatted_str[1:-1].strip()
+    elif formatted_str.startswith("(") and formatted_str.endswith(")"):
+        formatted_str = formatted_str[1:-1].strip()
+    elif formatted_str.startswith("{") and formatted_str.endswith("}"):
+        formatted_str = formatted_str[1:-1].strip()
+
+    # Handle different formats
+    if ", and " in formatted_str:  # Oxford comma format
+        parts = formatted_str.split(", and ")
+        if len(parts) > 1:
+            return [item.strip() for item in parts[0].split(", ")] + [parts[1].strip()]
+    elif " and " in formatted_str and ", " in formatted_str:  # No Oxford comma
+        parts = formatted_str.split(", ")
+        last_part = parts[-1]
+        if " and " in last_part:
+            last_items = last_part.split(" and ")
+            return [item.strip() for item in parts[:-1]] + [
+                item.strip() for item in last_items
+            ]
+    elif " and " in formatted_str:  # "and" separated format
+        return [item.strip() for item in formatted_str.split(" and ")]
+    elif ", " in formatted_str:  # Comma separated format
+        return [item.strip() for item in formatted_str.split(", ")]
+
+    # If none of the above patterns match, return the string as a single-item list
+    return [formatted_str.strip()]
+
+
+def get_derivative_targets(object_list, random_choice=True):
+    """Format a list of items in various natural ways"""
+    # Randomly choose from different formats
+    format_choices = {
+        "comma": lambda x: ", ".join(x),
+        "bracket": lambda x: "[" + ", ".join(x) + "]",
+        "parenthesis": lambda x: "(" + ", ".join(x) + ")",
+        "curly": lambda x: "{" + ", ".join(x) + "}",
+        "oxford_comma": lambda x: ", ".join(x[:-1]) + ", and " + x[-1],
+        "and_comma": lambda x: " and ".join(x[:-1]) + ", and " + x[-1],
+        "no_oxford_comma": lambda x: ", ".join(x[:-1]) + " and " + x[-1],
+        "and_separated": lambda x: " and ".join(x),
+    }
+
+    if random_choice:
+        format = random.choice(list(format_choices.keys()))
+        return format_choices[format](object_list)
+    else:
+        return [func(object_list) for format, func in format_choices.items()]
+
+
+def has_target_object(content: str, target_object: list):
+    derivative_objects = get_derivative_targets(target_object, random_choice=False)
+    return any([object in content.lower() for object in derivative_objects])
+
+
+def is_prediction(content: str, target_object: list):
+    if re.search(PREDICT_TEMP, content.lower()):
+        return True
+    else:
+        return False
+
+
+def is_correct_prediction(content: str, target_object: list):
+    derivative_objects = get_derivative_targets(target_object, random_choice=False)
+    if any(object in content.lower() for object in derivative_objects):
+        return True
+    
+    # Remove all punctuation from content except '.', '!', and ','
+    content = ''.join([c for c in content if not (c in set(string.punctuation) and c not in {'.', '!', ','})])
+    for feature in target_object:
+        if feature in content.lower():
+            continue
+        else:       
+            # Use a custom stemmer to handle cases like "crispy" -> "crisp"
+            def custom_stem(word):
+                if word.endswith("y") and len(word) > 3:
+                    return PSTEMMER.stem(word[:-1])
+                return PSTEMMER.stem(word)
+            feature_stem = custom_stem(feature.lower())
+            content_words = [word for word in content.lower().split()]
+            content_stems = [custom_stem(word) for word in content_words]
+            if not any(feature_stem == stem or feature_stem in stem for stem in content_stems):
+                return False
+    return True
+      
+    # derivative_objects = get_derivative_targets(target_object, random_choice=False)
+    # predict_regex = [PREDICT_TEMP + object for object in derivative_objects]
+    # if any([re.search(temp, content.lower()) for temp in predict_regex]):
+    #     return True
+    # else:
+    #     return False
+
+
+def get_game_outcome(history: List[Dict[str, str]], target_object: list, min_turns: int):
+    history_length = 0
+    for i, item in enumerate(history):
+        history_length += 1
+        if item["role"] == "listener":
+            if is_prediction(item["content"], target_object):
+                if is_correct_prediction(item["content"], target_object):
+                    return "game wins", history_length
+                else:
+                    return "game over", history_length
+            elif not has_target_object(item["content"], target_object) and i == len(history) - 1:
+                return "listener does not infer the target object", history_length
+        else:
+            if is_prediction(item["content"], target_object):
+                return "speaker breaks the rules", history_length
+
+    return "game over", history_length
+
+
+def convert_game_history_to_query(history, target, object_list):
+    GAME_RULE_PROMPT = GAME_RULE_PROMPTS[0]
+
+    history_str = ""
+    for i, message in enumerate(history):
+        history_str += "\n  - {}: {}".format(
+            message["role"], message["content"])
+
+    if len(history) == 0:
+        query = (
+            GAME_RULE_PROMPT +
+            + "The game is just initialized."
+        )
+        next_player = ROLES[0]
+    else:
+        query = (
+            GAME_RULE_PROMPT
+            + "\n### Game History:"
+            + history_str
+        )
+        if history[-1]["role"] == ROLES[0]:
+            next_player = ROLES[1]
+        else:
+            next_player = ROLES[0]
+
+    query += INSTRUCT_PROMPTS[next_player].format(
+        target=get_derivative_targets(target),
+        object_list=get_derivative_targets(object_list),
+    )
+
+    return query
+
+
+def randomly_convert_game_history_to_query(history, target, object_list, **kwargs):
+    if "random_seed" in kwargs:
+        random.seed(kwargs["random_seed"])
+
+    if len(history) == 0:
+        next_player = ROLES[0]
+    else:
+        if history[-1]["role"] == ROLES[0]:
+            next_player = ROLES[1]
+        else:
+            next_player = ROLES[0]
+
+    dialog_prefix = "\n" + random.choice(
+        ["\n - ", "\n### ", "\n## ", "\n# ", "\n *** ", "\n **", "\n\n"]
+    )
+    answer_str, question_str = random.choice(
+        [
+            (next_player, ROLES[1] if next_player == ROLES[0] else ROLES[0]),
+            ("Assistant", "Human"),
+            ("Answer", "Question"),
+            ("Response", "Query"),
+            ("A", "Q"),
+        ]
+    )
+
+    player_prefix = {
+        ROLES[0]: answer_str if next_player == ROLES[0] else question_str,
+        ROLES[1]: answer_str if next_player == ROLES[1] else question_str,
+    }
+
+    history_str = ""
+    for i, message in enumerate(history):
+        history_str += "{}{}: {}".format(
+            dialog_prefix, player_prefix[message["role"]], message["content"]
+        )
+
+    prompt_type = random.choice(["chat", "chat_inverse", "alpaca"])
+    system_prefix = random.choice(["Rules", "Game Rule", "System"])
+
+    system_prompt = random.choice(GAME_RULE_PROMPTS)
+
+    if isinstance(object_list, str):
+        objects_str = object_list
+    else:
+        objects_str = get_derivative_targets(object_list)
+    if "chat" in prompt_type:
+        system_prompt += "\n\n" + PLAYER_INSTRUCT_PROMPTS[next_player].format(
+            target=get_derivative_targets(target),
+            object_list=objects_str,
+        )
+
+        if len(history) == 0:
+            history_str = ""
+            system_prompt += "The game is just initialized. "
+
+        system_str = f"{dialog_prefix}{system_prefix}: {system_prompt}"
+        if "inverse" in prompt_type:
+            query = (
+                history_str
+                + system_str
+                + dialog_prefix
+                + player_prefix[next_player]
+                + ": "
+            )
+        else:
+            query = (
+                system_str
+                + history_str
+                + dialog_prefix
+                + player_prefix[next_player]
+                + ": "
+            )
+
+    elif prompt_type == "alpaca":
+        if random.uniform(0, 1) < 0.2:
+            system_prompt = system_prefix + ": " + system_prompt
+
+        if len(history) == 0:
+            query = system_prompt + "The game is just initialized. "
+        else:
+            query = (
+                system_prompt + dialog_prefix + "Game History:" + history_str + "\n\n"
+            )
+
+        if random.uniform(0, 1) < 0.2:
+            query += (
+                PLAYER_INSTRUCT_PROMPTS[next_player].format(
+                    target=target,
+                    object_list=objects_str,
+                )[:-1]
+                + ": "
+            )
+        else:
+            query += (
+                PLAYER_INSTRUCT_PROMPTS[next_player].format(
+                    target=target,
+                    object_list=objects_str,
+                )
+                + dialog_prefix
+                + player_prefix[next_player]
+                + ": "
+            )
+
+    return query

setup.py

@@ -0,0 +1,24 @@
+import sys
+import setuptools
+
+setuptools.setup(
+    name="archer",
+    version='0.1.0',
+    url="https://github.com/andreazanette/OfflineArcher.git",
+    author=("Andrea Zanette"),
+    description="Research code for Offline ArCHer (Actor Critic Framework with Hierarchical Structures)",
+    long_description=open("README.md", "r", encoding='utf-8').read(),
+    long_description_content_type="text/markdown",
+    keywords='ArCHer',
+    license='MIT',
+    packages=setuptools.find_packages(),
+    install_requires=open("requirements.txt", "r").read().split(),
+    include_package_data=True,
+    python_requires='>=3.7',
+    classifiers=[
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+    ],
+)

submit_BC_TwentyQuestions.sh

@@ -0,0 +1,25 @@
+#!/bin/bash -l
+# SLURM SUBMIT SCRIPT
+
+#SBATCH --nodelist=node-gpu01
+#SBATCH --gres=gpu:1    # Request N GPUs per machine
+
+. init.sh
+
+lr=1e-4
+batch_size=32
+accumulate_grad_batches=4 #8
+
+python main.py fit \
+--data=TwentyQuestions \
+--data.batch_size=$batch_size \
+--data.n_traj_eval=64 \
+--model=BehaviouralCloning \
+--model.lr=$lr \
+--trainer.fast_dev_run=False \
+--trainer.max_epoch=10 \
+--trainer.accumulate_grad_batches=$accumulate_grad_batches \
+--trainer.logger=WandbLogger \
+--trainer.logger.init_args.project="TwentyQuestions-Official" \
+--trainer.logger.init_args.name="BC-lr$lr" \
+--trainer.val_check_interval=500

submit_FBC_TwentyQuestions.sh

@@ -0,0 +1,26 @@
+#!/bin/bash -l
+# SLURM SUBMIT SCRIPT
+
+#SBATCH --nodelist=node-gpu01
+#SBATCH --gres=gpu:1    # Request N GPUs per machine
+
+. init.sh
+
+lr=1e-4
+batch_size=32
+accumulate_grad_batches=4 #8
+
+python main.py fit \
+--data=TwentyQuestions \
+--data.batch_size=$batch_size \
+--data.n_traj_eval=64 \
+--model=FilteredBehaviouralCloning \
+--model.lr=$lr \
+--model.filter=0.1 \
+--trainer.fast_dev_run=False \
+--trainer.max_epoch=100 \
+--trainer.accumulate_grad_batches=$accumulate_grad_batches \
+--trainer.logger=WandbLogger \
+--trainer.logger.init_args.project="TwentyQuestions-Official" \
+--trainer.logger.init_args.name="FBC-lr$lr" \
+--trainer.val_check_interval=500

submit_OfflineArcher_RSA.sh

@@ -0,0 +1,166 @@
+#!/bin/bash -l
+# SLURM SUBMIT SCRIPT
+
+#SBATCH --nodelist=node-gpu01
+#SBATCH --gres=gpu:1    # Request N GPUs per machine
+
+export TMPDIR=$HOME/tmp
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:64,expandable_segments:True
+export NCCL_P2P_DISABLE=1
+export CUDA_LAUNCH_BLOCKING=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_NSOCKS_PERTHREAD=4
+export NCCL_SOCKET_NTHREADS=2
+export PYTORCH_NO_CUDA_MEMORY_CACHING=1  # 禁用缓存
+export MAX_JOBS=4  # 限制并行加载
+export ACCELERATE_USE_DEEPSPEED="true" 
+export TORCH_USE_CUDA_DSA=1
+
+
+actor_lr=1e-5
+critic_lr=1e-5
+
+critic_expectile=0.9
+inv_temp=1.0
+
+batch_size=2
+accumulate_grad_batches=16 #8
+
+echo "当前conda环境: $(which python)"
+echo "python版本: $(python --version)"
+echo "accelerate版本: $(accelerate --version)"
+echo "CUDA_VISIBLE_DEVICES: $CUDA_VISIBLE_DEVICES"
+echo "nvidia-smi:"
+nvidia-smi
+
+echo "==== 测试python能否运行 ===="
+python -c "print('Python可以运行')"
+
+echo "==== 测试main.py是否存在 ===="
+ls -l "$HOME/codes/OfflineArcher/main.py"
+
+echo "==== 测试accelerate能否import torch ===="
+accelerate launch --help || echo "accelerate launch命令无法运行"
+
+echo "==== 开始正式训练 ===="
+
+set -x  # 打印每一行命令，方便debug
+
+accelerate launch \
+    --config_file "$HOME/codes/OfflineArcher/deepspeed_zero3.yaml" \
+    --num_processes 4 \
+    --gpu_ids 4,5,6,7 \
+    --main_process_port 29500 \
+    "$HOME/codes/OfflineArcher/main.py" \
+    fit \
+    --data=RSAGame \
+    --data.batch_size=2 \
+    --data.base_model="Qwen3-14B" \
+    --data.n_traj_eval=4 \
+    --model=OfflineArcher \
+    --model.optimize_critic=True \
+    --model.actor_lr=$actor_lr \
+    --model.critic_lr=$critic_lr \
+    --model.discount_factor=0.99 \
+    --model.tau=0.05 \
+    --model.critic_expectile=$critic_expectile \
+    --model.inv_temp=$inv_temp \
+    --model.accumulate_grad_batches=4 \
+    --model.model_name_or_path="/home/jiashuo/codes/ForesightOptim/checkpoints/im_Qwen3-14B_word/merged_model" \
+    --trainer.fast_dev_run=False \
+    --trainer.max_epoch=1 \
+    --trainer.logger=WandbLogger \
+    --trainer.logger.init_args.project="WordTaboo-Official" \
+    --trainer.default_root_dir="checkpoints/archer_Qwen3-14B_word" \
+    --trainer.logger.init_args.name="Test-AC-critic_expectile_$critic_expectile-inv_temp_$inv_temp" \
+    --trainer.strategy=deepspeed_stage_3 \
+    --trainer.devices=4 \
+    --trainer.accelerator=gpu \
+    --trainer.precision=bf16 \
+    --trainer.enable_model_summary=false \
+    --trainer.val_check_interval=null \
+    --trainer.limit_val_batches=0 > Qwen3-14B_RSA_log.txt 2>&1
+
+echo "第三个任务返回码: $?"
+tail -20 Qwen3-14B_RSA_log.txt
+
+
+accelerate launch \
+    --config_file "$HOME/codes/OfflineArcher/deepspeed_zero3.yaml" \
+    --num_processes 4 \
+    --gpu_ids 4,5,6,7 \
+    --main_process_port 29500 \
+    "$HOME/codes/OfflineArcher/main.py" \
+    fit \
+    --data=WordTaboo \
+    --data.batch_size=2 \
+    --data.base_model="Qwen3-14B" \
+    --data.n_traj_eval=4 \
+    --model=OfflineArcher \
+    --model.optimize_critic=True \
+    --model.actor_lr=$actor_lr \
+    --model.critic_lr=$critic_lr \
+    --model.discount_factor=0.99 \
+    --model.tau=0.05 \
+    --model.critic_expectile=$critic_expectile \
+    --model.inv_temp=$inv_temp \
+    --model.accumulate_grad_batches=4 \
+    --model.model_name_or_path="/home/jiashuo/codes/ForesightOptim/checkpoints/im_Qwen3-14B_word/merged_model" \
+    --trainer.fast_dev_run=False \
+    --trainer.max_epoch=1 \
+    --trainer.logger=WandbLogger \
+    --trainer.logger.init_args.project="WordTaboo-Official" \
+    --trainer.default_root_dir="checkpoints/archer_Qwen3-14B_word" \
+    --trainer.logger.init_args.name="Test-AC-critic_expectile_$critic_expectile-inv_temp_$inv_temp" \
+    --trainer.strategy=deepspeed_stage_3 \
+    --trainer.devices=4 \
+    --trainer.accelerator=gpu \
+    --trainer.precision=bf16 \
+    --trainer.enable_model_summary=false \
+    --trainer.val_check_interval=null \
+    --trainer.limit_val_batches=0 > Qwen3-14B_Word_log.txt 2>&1
+
+echo "第三个任务返回码: $?"
+tail -20 Qwen3-14B_Word_log.txt
+
+accelerate launch \
+    --config_file "$HOME/codes/OfflineArcher/deepspeed_zero3.syaml" \
+    --num_processes 4 \
+    --gpu_ids 4,5,6,7 \
+    --main_process_port 29500 \
+    "$HOME/codes/OfflineArcher/main.py" \
+    fit \
+    --data=StrategicDialogue \
+    --data.batch_size=2 \
+    --data.base_model="Qwen3-14B" \
+    --data.n_traj_eval=4 \
+    --model=OfflineArcher \
+    --model.optimize_critic=True \
+    --model.actor_lr=$actor_lr \
+    --model.critic_lr=$critic_lr \
+    --model.discount_factor=0.99 \
+    --model.tau=0.05 \
+    --model.critic_expectile=$critic_expectile \
+    --model.inv_temp=$inv_temp \
+    --model.accumulate_grad_batches=4 \
+    --model.model_name_or_path="/home/jiashuo/codes/ForesightOptim/checkpoints/im_Qwen3-14B_strategic/merged_model" \
+    --trainer.fast_dev_run=False \
+    --trainer.max_epoch=1 \
+    --trainer.logger=WandbLogger \
+    --trainer.logger.init_args.project="Strategic-Official" \
+    --trainer.default_root_dir="checkpoints/archer_Qwen3-14B_strategic" \
+    --trainer.logger.init_args.name="Test-AC-critic_expectile_$critic_expectile-inv_temp_$inv_temp" \
+    --trainer.strategy=deepspeed_stage_3 \
+    --trainer.devices=4 \
+    --trainer.accelerator=gpu \
+    --trainer.precision=bf16 \
+    --trainer.enable_model_summary=false \
+    --trainer.val_check_interval=null \
+    --trainer.limit_val_batches=0 > Qwen3-14B_Strategic_log.txt 2>&1
+
+echo "第五个任务返回码: $?"
+tail -20 Qwen3-14B_Strategic_log.txt
+
+set +x
+
+echo "所有任务执行完毕。请检查上面各个log文件的最后20行和返回码。"

submit_OfflineArcher_TwentyQuestions.sh

@@ -0,0 +1,37 @@
+#!/bin/bash -l
+# SLURM SUBMIT SCRIPT
+
+#SBATCH --nodelist=node-gpu01
+#SBATCH --gres=gpu:1    # Request N GPUs per machine
+
+. init.sh
+
+actor_lr=1e-4
+critic_lr=1e-5
+
+critic_expectile=0.9
+inv_temp=1.0
+
+batch_size=32
+accumulate_grad_batches=4 #8
+
+python main.py fit \
+--data=TwentyQuestions \
+--data.batch_size=$batch_size \
+--data.n_traj_eval=64 \
+--model=OfflineArcher \
+--model.optimize_critic=True \
+--model.actor_lr=$actor_lr \
+--model.critic_lr=$critic_lr \
+--model.discount_factor=0.99 \
+--model.tau=0.05 \
+--model.critic_expectile=$critic_expectile \
+--model.inv_temp=$inv_temp \
+--model.accumulate_grad_batches=$accumulate_grad_batches \
+--trainer.fast_dev_run=False \
+--trainer.max_epoch=10 \
+--trainer.logger=WandbLogger \
+--trainer.logger.init_args.project="TwentyQuestions-Official" \
+--trainer.logger.init_args.name="Test-AC-critic_expectile_$critic_expectile-inv_temp_$inv_temp" \
+--trainer.strategy='ddp_find_unused_parameters_true' \
+--trainer.val_check_interval=250

test.py

@@ -0,0 +1,34 @@
+from peft import PeftModel, PeftConfig
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import os
+
+# Configuration - replace these with your actual paths
+LORA_MODEL_PATH = "./checkpoints/archer_Qwen3-14B_rsa"     # e.g., "./lora_output"
+BASE_MODEL_NAME = "/home/jiashuo/codes/ForesightOptim/checkpoints/im_Qwen3-14B_rsa/merged_model"         # e.g., "./merged_model"
+
+def merge_lora(base_model_name, lora_path, output_path):
+    # Load base model
+    base_model = AutoModelForCausalLM.from_pretrained(
+        base_model_name,
+        return_dict=True,
+        torch_dtype=torch.float16,
+        device_map="auto"
+    )
+    
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+    
+    # Load LoRA adapter
+    lora_model = PeftModel.from_pretrained(base_model, lora_path)
+    
+    # Merge weights
+    merged_model = lora_model.merge_and_unload()
+    
+    # Save merged model
+    merged_model.save_pretrained(output_path)
+    tokenizer.save_pretrained(output_path)
+    print(f"Merged model saved to {output_path}")
+
+if __name__ == "__main__":
+    merge_lora(BASE_MODEL_NAME, LORA_MODEL_PATH, os.path.join(LORA_MODEL_PATH, "merged_model"))