from .ctx_manager import ContextManager from .es_manager import EnvStateManager from vllm import LLM, SamplingParams from verl.single_controller.ray.base import RayWorkerGroup from transformers import AutoTokenizer, AutoModelForCausalLM from verl import DataProto import hydra import os from pathlib import Path from typing import List, Dict, Optional from verl.protocol import pad_dataproto_to_divisor, unpad_dataproto from .base_llm import ConcurrentLLM import time from hydra.utils import to_absolute_path import numpy as np from omegaconf import OmegaConf, open_dict import wandb class VllmWrapperWg: # Thi is a developing class for eval and test def __init__(self, config, tokenizer): self.config = config self.tokenizer = tokenizer model_name = config.actor_rollout_ref.model.path ro_config = config.actor_rollout_ref.rollout log_stats_interval = getattr(ro_config, "log_stats_interval", None) llm_kwargs = dict( enable_sleep_mode=True, tensor_parallel_size=ro_config.tensor_model_parallel_size, dtype=ro_config.dtype, enforce_eager=ro_config.enforce_eager, gpu_memory_utilization=ro_config.gpu_memory_utilization, disable_custom_all_reduce=True, disable_mm_preprocessor_cache=True, skip_tokenizer_init=False, max_model_len=ro_config.max_model_len, disable_log_stats=ro_config.disable_log_stats, max_num_batched_tokens=ro_config.max_num_batched_tokens, enable_chunked_prefill=ro_config.enable_chunked_prefill, enable_prefix_caching=True, trust_remote_code=True, ) if log_stats_interval is not None: llm_kwargs["log_stats_interval"] = log_stats_interval self.llm = LLM( model_name, **llm_kwargs, ) print("LLM initialized") self.sampling_params = SamplingParams( max_tokens=ro_config.response_length, temperature=ro_config.val_kwargs.temperature, top_p=ro_config.val_kwargs.top_p, top_k=ro_config.val_kwargs.top_k, logprobs=ro_config.val_kwargs.logprobs, # min_p=0.1, ) def generate_sequences(self, lm_inputs: DataProto): """ Convert the input ids to text, and then generate the sequences. Finally create a dataproto. This aligns with the verl Worker Group interface. """ # NOTE: free_cache_engine is not used in the vllm wrapper. Only used in the verl vllm. # cache_action = lm_inputs.meta_info.get('cache_action', None) if lm_inputs.meta_info.get("skip_generation", False): return lm_inputs input_ids = lm_inputs.batch['input_ids'] input_texts = self.tokenizer.batch_decode(input_ids, skip_special_tokens=False) input_texts = [i.replace("<|endoftext|>", "") for i in input_texts] outputs = self.llm.generate(input_texts, sampling_params=self.sampling_params) texts = [output.outputs[0].text for output in outputs] # get the entropy of the response entropys = [] all_logprobs = [output.outputs[0].logprobs for output in outputs] for logprob_in_a_series in all_logprobs: entropy_of_the_series = [] for logprob_in_a_token in logprob_in_a_series: logprobs = np.array([i.logprob for i in logprob_in_a_token.values()]) entropy_of_the_token = - (logprobs * np.exp(logprobs)).sum() entropy_of_the_series.append(entropy_of_the_token) entropy_of_the_series = np.array(entropy_of_the_series) entropy_of_the_series = entropy_of_the_series.sum() entropys.append(entropy_of_the_series) entropys = np.array(entropys) n_tokens = [len(logprob_in_a_series) for logprob_in_a_series in all_logprobs] n_tokens = np.array(n_tokens) # get the in_group_std of the response lm_outputs = DataProto() lm_outputs.non_tensor_batch = { 'response_texts': texts, 'env_ids': lm_inputs.non_tensor_batch['env_ids'], 'group_ids': lm_inputs.non_tensor_batch['group_ids'], 'entropys': entropys, 'n_tokens': n_tokens, } # this is a bit hard-coded to bypass the __init__ check in DataProto lm_outputs.meta_info = lm_inputs.meta_info return lm_outputs class ApiCallingWrapperWg: """Wrapper class for API-based LLM calls that fits into the VERL framework""" def __init__(self, config, tokenizer): self.config = config self.tokenizer = tokenizer model_info = config.model_info[config.model_config.model_name] self.llm_kwargs = model_info.generation_kwargs api_key = OmegaConf.select(model_info, "api_key", default=None) self.llm = ConcurrentLLM( provider=model_info.provider_name, model_name=model_info.model_name, api_key=api_key, max_concurrency=config.model_config.max_concurrency ) print(f'API-based LLM ({model_info.provider_name} - {model_info.model_name}) initialized') def generate_sequences(self, lm_inputs: DataProto) -> DataProto: """ Convert the input ids to text, make API calls to generate responses, and create a DataProto with the results. """ if lm_inputs.meta_info.get("skip_generation", False): return lm_inputs messages_list = lm_inputs.non_tensor_batch['messages_list'].tolist() results, failed_messages = self.llm.run_batch( messages_list=messages_list, **self.llm_kwargs ) assert not failed_messages, f"Failed to generate responses for the following messages: {failed_messages}" texts = [result["response"] for result in results] print(f'[DEBUG] texts: {texts}') lm_outputs = DataProto() lm_outputs.non_tensor_batch = { 'response_texts': texts, 'env_ids': lm_inputs.non_tensor_batch['env_ids'], 'group_ids': lm_inputs.non_tensor_batch['group_ids'] } # this is a bit hard-coded to bypass the __init__ check in DataProto lm_outputs.meta_info = lm_inputs.meta_info return lm_outputs class LLMAgentProxy: """ The proxy means the llm agent is trying to generate some rollout **at this time**, **at this model state**, **at this env state from the env config** """ def __init__(self, config, actor_rollout_wg, tokenizer): self.config = config self.train_ctx_manager = ContextManager(config, tokenizer, mode="train") self.train_es_manager = EnvStateManager(config, mode="train") self.val_ctx_manager = ContextManager(config, tokenizer, mode="val") self.val_es_manager = EnvStateManager(config, mode="val") self.actor_wg = actor_rollout_wg self.tokenizer = tokenizer self._last_padded_inputs = None def generate_sequences(self, lm_inputs: DataProto): # TODO: add kv cache both for the vllm wrapper here and for verl vllm. if isinstance(self.actor_wg, RayWorkerGroup): padded_lm_inputs, pad_size = pad_dataproto_to_divisor(lm_inputs, self.actor_wg.world_size) self._last_padded_inputs = padded_lm_inputs padded_lm_outputs = self.actor_wg.generate_sequences( padded_lm_inputs ) if lm_inputs.meta_info.get("skip_generation", False): return lm_inputs lm_outputs = unpad_dataproto(padded_lm_outputs, pad_size=pad_size) lm_outputs.meta_info = lm_inputs.meta_info lm_outputs.non_tensor_batch = lm_inputs.non_tensor_batch elif isinstance(self.actor_wg, VllmWrapperWg) or isinstance(self.actor_wg, ApiCallingWrapperWg): lm_outputs = self.actor_wg.generate_sequences(lm_inputs) else: raise ValueError(f"Unsupported actor worker type: {type(self.actor_wg)}") return lm_outputs def rollout(self, dataproto: DataProto, val=False): es_manager = self.val_es_manager if val else self.train_es_manager ctx_manager = self.val_ctx_manager if val else self.train_ctx_manager env_outputs = es_manager.reset() max_turn = self.config.agent_proxy.max_turn multi_turn = max_turn > 1 finalized = False last_inputs = None n_tokens, entropys = np.zeros(len(env_outputs)), np.zeros(len(env_outputs)) # to calculate instance-level entropy for i in range(max_turn): if len(env_outputs) == 0: break lm_inputs: DataProto = ctx_manager.get_lm_inputs(env_outputs, prepare_for_update=False) lm_inputs.meta_info = dataproto.meta_info # TODO: setup vllm early stop when max length is reached. make sure this can be done last_inputs = lm_inputs if multi_turn: if i == 0: mode = "multiturn-start" elif i == max_turn - 1: mode = "multiturn-end" else: mode = "multiturn-middle" else: mode = "singleturn" lm_inputs.meta_info["mode"] = mode lm_outputs: DataProto = self.generate_sequences(lm_inputs) # calculate entropy if 'entropys' in lm_outputs.non_tensor_batch: turn_entropy, env_ids = lm_outputs.non_tensor_batch['entropys'], lm_outputs.non_tensor_batch['env_ids'] n_tokens[env_ids] += lm_outputs.non_tensor_batch['n_tokens'] entropys[env_ids] += turn_entropy if mode == "multiturn-end": finalized = True env_inputs: List[Dict] = ctx_manager.get_env_inputs(lm_outputs) env_outputs: List[Dict] = es_manager.step(env_inputs) if len(env_outputs) == 0: # all finished if multi_turn and not finalized and last_inputs is not None: last_inputs.meta_info["skip_generation"] = True last_inputs.meta_info["mode"] = "multiturn-end" self.generate_sequences(last_inputs) finalized = True break if multi_turn and not finalized and last_inputs is not None: last_inputs.meta_info["skip_generation"] = True last_inputs.meta_info["mode"] = "multiturn-end" self.generate_sequences(last_inputs) rollout_states = es_manager.get_rollout_states() rollouts = ctx_manager.formulate_rollouts(rollout_states) # calculate instance-level entropy if 'entropys' in rollouts.non_tensor_batch: rollouts.non_tensor_batch['entropys'] = entropys / n_tokens rollouts.non_tensor_batch['n_generated_tokens'] = n_tokens return rollouts def _normalize_output_cfg(config) -> Optional[Dict]: if not hasattr(config, "output"): return None return OmegaConf.to_object(config.output) def _build_save_path(config, output_cfg: Optional[Dict], timestamp: str) -> str: if output_cfg is None: trainer_cfg = getattr(config, "trainer", None) base_dir_raw = getattr(trainer_cfg, "local_log_dir", "results") if trainer_cfg is not None else "results" exp_name = getattr(trainer_cfg, "experiment_name", "eval") if trainer_cfg is not None else "eval" base_dir = to_absolute_path(base_dir_raw) save_dir = os.path.join(base_dir, f"{exp_name}_{timestamp}") os.makedirs(save_dir, exist_ok=True) return os.path.join(save_dir, "val_rollouts.pkl") output_dir = to_absolute_path(output_cfg.get("dir", "results/eval")) os.makedirs(output_dir, exist_ok=True) filename = output_cfg.get("filename") or "val_rollouts.pkl" append_timestamp = output_cfg.get("append_timestamp", True) root, ext = os.path.splitext(filename) if not ext: ext = ".pkl" if append_timestamp: filename = f"{root}_{timestamp}{ext}" else: filename = f"{root}{ext}" return os.path.join(output_dir, filename) @hydra.main(version_base=None, config_path="../../config", config_name="eval") def main(config): # detect config name from python -m ragen.llm_agent.agent_proxy --config_name frozen_lake print("Starting evaluation process. Check config/eval.yaml for specific configs.") os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn" os.environ["CUDA_VISIBLE_DEVICES"] = str(config.system.CUDA_VISIBLE_DEVICES) tokenizer = AutoTokenizer.from_pretrained(config.actor_rollout_ref.model.path) actor_wg = VllmWrapperWg(config, tokenizer) proxy = LLMAgentProxy(config, actor_wg, tokenizer) import time start_time = time.time() # import pdb;pdb.set_trace() rollouts = proxy.rollout( DataProto( batch=None, non_tensor_batch=None, meta_info={ 'eos_token_id': 151645, 'pad_token_id': 151643, 'recompute_log_prob': False, 'do_sample': config.actor_rollout_ref.rollout.do_sample, 'validate': True } ), val=True ) end_time = time.time() print(f'rollout time: {end_time - start_time} seconds') # print rollout rewards from the rm_scores rm_scores = rollouts.batch["rm_scores"] metrics = rollouts.meta_info["metrics"] avg_reward = rm_scores.sum(-1).mean().item() print(f'rollout rewards: {avg_reward}') print(f'metrics:') for k, v in metrics.items(): print(f'{k}: {v}') # save to config.trainer.local_log_dir/config.trainer.experiment_name + _ + timestamp timestamp = time.strftime("%Y%m%d_%H%M%S") output_cfg = _normalize_output_cfg(config) save_path = _build_save_path(config, output_cfg, timestamp) rollouts.save_to_disk(save_path) dir_path = os.path.dirname(save_path) print(f'save validation results to {save_path}. To visualize, run: python scripts/visualize.py --rollout_path {dir_path}') if __name__ == "__main__": import sys sys.argv.extend([ "--config-dir", os.path.join(os.path.dirname(__file__), "../../ragen/config"), "--config-dir", os.path.join(os.path.dirname(__file__), "../../verl/verl/trainer/config"), ]) main()