Upload 5 files

my_ppo_config.py

@@ -0,0 +1,240 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import json
+import os
+import sys
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+import numpy as np
+import tyro
+from transformers import is_wandb_available
+from typing_extensions import Annotated
+
+from trl.trainer.utils import exact_div
+
+from trl.core import flatten_dict
+
+
+JSONDict = Annotated[Optional[dict], tyro.conf.arg(metavar="JSON", constructor=json.loads)]
+
+
+@dataclass
+class PPOConfig:
+    r"""
+    Configuration class for the [`PPOTrainer`].
+
+    Using [`~transformers.HfArgumentParser`] we can turn this class into
+    [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the
+    command line.
+
+    Parameters:
+        exp_name (`str`, *optional*, defaults to `os.path.basename(__file__)[: -len(".py")]`):
+            Name of this experiment.
+        seed (`int`, *optional*, defaults to `0`):
+            Random seed.
+        log_with (`Optional[Literal["wandb", "tensorboard"]]`, *optional*, defaults to `None`):
+            Log with either `"wandb"` or `"tensorboard"`. Check
+            [tracking](https://huggingface.co/docs/accelerate/usage_guides/tracking) for more details.
+        task_name (`Optional[str]`, *optional*, defaults to `None`):
+            Name of task to use - used only for tracking purposes.
+        model_name (`Optional[str]`, *optional*, defaults to `"gpt2"`):
+            Name of model to use - used only for tracking purposes.
+        query_dataset (`Optional[str]`, *optional*, defaults to `"stanfordnlp/imdb"`):
+            Name of dataset to query - used only for tracking purposes.
+        reward_model (`Optional[str]`, *optional*, defaults to `"sentiment-analysis:lvwerra/distilbert-imdb"`):
+            Reward model to use - used only for tracking purposes.
+        remove_unused_columns (`bool`, *optional*, defaults to `True`):
+            Remove unused columns from the dataset.
+        tracker_kwargs (`JSONDict`, *optional*, defaults to `{}`):
+            Keyword arguments for the tracker (e.g. `python ppo.py --tracker_kwargs='{"wandb": {"entity": "my_wandb_entity", "name": "my_exp_name"}}'`.
+        accelerator_kwargs (`JSONDict`, *optional*, defaults to `{}`):
+            Keyword arguments for the accelerator.
+        project_kwargs (`JSONDict`, *optional*, defaults to `{}`):
+            Keyword arguments for the accelerator project config (e.g. `logging_dir`).
+        tracker_project_name (`str`, *optional*, defaults to `"trl"`):
+            Name of project to use for tracking.
+        push_to_hub_if_best_kwargs (`JSONDict`, *optional*, defaults to `{}`):
+            Keyword arguments for pushing model to the hub during training (e.g. repo_id).
+        steps (`int`, *optional*, defaults to `20000`):
+            Number of training steps.
+        learning_rate (`float`, *optional*, defaults to `1.41e-5`):
+            Learning rate for the optimizer.
+        adap_kl_ctrl (`bool`, *optional*, defaults to `True`):
+            Use adaptive KL control, otherwise linear.
+        init_kl_coef (`Optional[float]`, *optional*, defaults to `0.2`):
+            Initial KL penalty coefficient (used for adaptive and linear control).
+        kl_penalty (`Literal["kl", "abs", "mse", "full"]`, *optional*, defaults to `"kl"`):
+            kl penalty options. Possible values are:
+
+                - `"kl"`: model_logp - ref_logp
+                - `"abs"`: abs(kl)
+                - `"mse"`: mean squared error mse(kl)
+                - `"full"`: the actual kl for all tokens in the distribution.
+
+        target (`float`, *optional*, defaults to `6.0`):
+            Target KL value for adaptive KL control.
+        horizon (`float`, *optional*, defaults to `10000.0`):
+            Horizon for adaptive KL control.
+        gamma (`float`, *optional*, defaults to `1.0`):
+            Gamma parameter for advantage calculation.
+        lam (`float`, *optional*, defaults to `0.95`):
+            Lambda parameter for advantage calculation.
+        cliprange (`float`, *optional*, defaults to `0.2`):
+            Range for clipping in PPO policy gradient loss.
+        cliprange_value (`float`, *optional*, defaults to `0.2`):
+            Range for clipping values in loss calculation.
+        vf_coef (`float`, *optional*, defaults to `0.1`):
+            Scaling factor for value loss.
+        batch_size (`int`, *optional*, defaults to `128`):
+            Number of samples per optimisation step.
+        forward_batch_size (`Optional[int]`, *optional*, defaults to `None`):
+            DEPRECATED: use `mini_batch_size` instead, which does the same thing.
+        mini_batch_size (`int`, *optional*, defaults to `128`):
+            Number of samples optimized in each mini batch.
+        gradient_accumulation_steps (`int`, *optional*, defaults to `1`):
+            Number of gradient accumulation steps.
+        world_size (`Optional[int]`, *optional*, defaults to `None`):
+            Number of processes to use for distributed training.
+        ppo_epochs (`int`, *optional*, defaults to `4`):
+            Number of optimisation epochs per batch of samples.
+        optimize_device_cache (`bool`, *optional*, defaults to `False`):
+            Optimize device cache for slightly more memory-efficient training.
+        early_stopping (`bool`, *optional*, defaults to `False`):
+            Whether to stop the PPO optimization loop early is the KL too high.
+        target_kl (`float`, *optional*, defaults to `1.0`):
+            Stop early if we exceed this value by over 50%.
+        compare_steps (`int`, *optional*, defaults to `1`):
+            Compare the current step with the previous `compare_steps` steps.
+        ratio_threshold (`float`, *optional*, defaults to `10.0`):
+            Skip mini-batches with high PPO ratios that can cause loss spikes.
+        use_score_scaling (`bool`, *optional*, defaults to `False`):
+            Use score scaling.
+        use_score_norm (`bool`, *optional*, defaults to `False`):
+            Use score normalization. Only applicable if `use_score_scaling` is True.
+        score_clip (`Optional[float]`, *optional*, defaults to `None`):
+            Score clipping.
+        whiten_rewards (`bool`, *optional*, defaults to `False`):
+            Whiten the rewards before computing advantages.
+        is_encoder_decoder (`Optional[bool]`, *optional*, defaults to `None`):
+            When using the `model_init` argument (callable) to instantiate the model instead of the `model` argument,
+            you need to specify if the model returned by the callable is an encoder-decoder model.
+        is_peft_model (`Optional[bool]`, *optional*, defaults to `None`):
+            Whether the model is a PEFT model.
+        backward_batch_size (`Optional[int]`, *optional*, defaults to `None`):
+            Number of samples optimized in an `optimizer.step()` call.
+        global_backward_batch_size (`Optional[int]`, *optional*, defaults to `None`):
+            Effective `backward_batch_size` across all processes.
+        global_batch_size (`Optional[int]`, *optional*, defaults to `None`):
+            Effective `batch_size` across all processes.
+        dataset_num_proc (`Optional[int]`, *optional*, defaults to `None`):
+            Number of processes to use for processing the dataset.
+    """
+
+    exp_name: str = os.path.basename(sys.argv[0])[: -len(".py")]
+    seed: int = 0
+    log_with: Optional[Literal["wandb", "tensorboard"]] = None
+    task_name: Optional[str] = None
+    model_name: str = "gpt2"
+    query_dataset: str = "stanfordnlp/imdb"
+    reward_model: str = "sentiment-analysis:lvwerra/distilbert-imdb"
+    remove_unused_columns: bool = True
+    tracker_kwargs: JSONDict = field(default_factory=dict)
+    accelerator_kwargs: JSONDict = field(default_factory=dict)
+    project_kwargs: JSONDict = field(default_factory=dict)
+    tracker_project_name: str = "trl"
+    push_to_hub_if_best_kwargs: JSONDict = field(default_factory=dict)
+    steps: int = 20000
+    learning_rate: float = 1.41e-5
+    adap_kl_ctrl: bool = True
+    init_kl_coef: float = 0.2
+    kl_penalty: Literal["kl", "abs", "mse", "full", "control_variate", "seq_control_variate"] = "kl"
+    target: float = 6.0
+    horizon: float = 10000.0
+    gamma: float = 1.0
+    lam: float = 0.95
+    cliprange: float = 0.2
+    cliprange_value: float = 0.2
+    vf_coef: float = 0.1
+    batch_size: int = 128
+    forward_batch_size: Optional[int] = None
+    mini_batch_size: int = 128
+    gradient_accumulation_steps: int = 1
+    world_size: tyro.conf.Suppress[int] = None
+    ppo_epochs: int = 4
+    max_grad_norm: Optional[float] = None
+    optimize_cuda_cache: Optional[bool] = None
+    optimize_device_cache: bool = False
+    early_stopping: bool = False
+    target_kl: float = 1.0
+    compare_steps: int = 1
+    ratio_threshold: float = 10.0
+    use_score_scaling: bool = False
+    use_score_norm: bool = False
+    score_clip: Optional[float] = None
+    whiten_rewards: bool = False
+    whiten_advantages: bool = False
+    gradient_checkpointing: bool = False
+    is_encoder_decoder: Optional[tyro.conf.Suppress[bool]] = None
+    is_peft_model: Optional[tyro.conf.Suppress[bool]] = None
+    backward_batch_size: tyro.conf.Suppress[int] = None
+    global_backward_batch_size: Optional[tyro.conf.Suppress[int]] = None
+    global_batch_size: tyro.conf.Suppress[int] = None
+    dataset_num_proc: Optional[int] = None
+
+    if optimize_cuda_cache is not None:
+        warnings.warn(
+            "The `optimize_cuda_cache` argument will be deprecated soon, please use `optimize_device_cache` instead."
+        )
+
+        if optimize_device_cache is True:
+            raise ValueError("Both `optimize_device_cache` and `optimize_cuda_cache` were provided")
+
+        optimize_device_cache = optimize_cuda_cache
+
+    def __post_init__(self):
+        warnings.warn(
+            "`PPOConfig` is deprecated and will be removed in the future. Please use `PPOv2Config` with `PPOv2Trainer` instead.",
+            FutureWarning,
+        )
+        if self.forward_batch_size is not None:
+            warnings.warn(
+                "Note that using `forward_batch_size` is deprecated, use `mini_batch_size` instead. By setting it you overwrite `mini_batch_size` which affects both the batch size during forward passes and also the mini batch size for PPO optimization."
+            )
+            self.mini_batch_size = self.forward_batch_size
+
+        self.backward_batch_size = self.mini_batch_size * self.gradient_accumulation_steps
+        exact_div(
+            self.batch_size,
+            self.backward_batch_size,
+            "`batch_size` must be a multiple of `mini_batch_size * gradient_accumulation_steps`",
+        )
+
+        # check if wandb is installed
+        if self.log_with == "wandb":
+            # raise error if wandb is not installed
+            if not is_wandb_available():
+                raise ImportError(
+                    "Please install wandb to use wandb logging. You can do this by running `pip install wandb`."
+                )
+
+        self.total_ppo_epochs = int(np.ceil(self.steps / self.batch_size))
+        assert self.kl_penalty in ["kl", "abs", "mse", "full", "control_variate", "seq_control_variate"]
+
+    def to_dict(self):
+        output_dict = {}
+        for key, value in self.__dict__.items():
+            output_dict[key] = value
+        return flatten_dict(output_dict)

my_ppo_trainer_v1.py

@@ -0,0 +1,716 @@
+# Copyright 2024 HuggingFace Inc. and the LlamaFactory team.
+#
+# This code is inspired by the HuggingFace's TRL library.
+# https://github.com/huggingface/trl/blob/v0.8.0/trl/trainer/ppo_trainer.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+import json
+import os
+import sys
+import copy
+import warnings
+from types import MethodType
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from accelerate.utils import DummyOptim, DummyScheduler
+
+import torch
+from accelerate.utils import DistributedDataParallelKwargs
+from tqdm import tqdm
+from transformers import GenerationConfig, Trainer, TrainerControl, TrainerState
+from transformers.optimization import get_scheduler
+from transformers.trainer import DEFAULT_CALLBACKS
+from transformers.trainer_callback import CallbackHandler
+from transformers.trainer_pt_utils import remove_dummy_checkpoint
+from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR
+from transformers.utils import SAFE_WEIGHTS_NAME, WEIGHTS_NAME
+from trl.core import PPODecorators, logprobs_from_logits
+from trl.models.utils import unwrap_model_for_generation
+from typing_extensions import override
+
+from my_ppo_config import PPOConfig
+from ppo_trainer import PPOTrainer
+from ppo_trainer_v1 import PPOTrainerV1
+from trl.core import PPODecorators, logprobs_from_logits
+from trl.models.utils import unwrap_model_for_generation
+from typing_extensions import override
+
+from llamafactory.extras.logging import get_logger
+from llamafactory.extras.misc import AverageMeter, count_parameters, get_current_device, get_logits_processor
+from llamafactory.train.callbacks import SaveProcessorCallback
+from llamafactory.train.trainer_utils import create_custom_optimizer, create_custom_scheduler
+from llamafactory.train.ppo.ppo_utils import dump_layernorm, replace_model, restore_layernorm
+from iTrainingLogger import iSummaryWriter
+from ppo_save_utils import FixValueHeadModelCallback
+import torch.distributed as dist
+import numpy as np
+from transformers.integrations.deepspeed import deepspeed_init
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+    from transformers import (
+        DataCollatorWithPadding,
+        PreTrainedTokenizer,
+        ProcessorMixin,
+        Seq2SeqTrainingArguments,
+        TrainerCallback,
+    )
+    from trl import AutoModelForCausalLMWithValueHead
+
+    from llamafactory.hparams import FinetuningArguments, GeneratingArguments, ModelArguments
+
+import logging
+
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+from step_dpo_reward import get_rewards_from_server, get_rewards_from_rule
+import re
+import numpy as np
+from trl.trainer.utils import (
+    disable_dropout_in_model
+)
+
+RM_TYPE = os.environ.get('RM_TYPE', 'RULE')
+if RM_TYPE == 'RULE':
+    get_rewards_from_fn = get_rewards_from_rule
+elif RM_TYPE == 'BT_RM':
+    get_rewards_from_fn = get_rewards_from_server
+else:
+    get_rewards_from_fn = get_rewards_from_rule
+    
+print(get_rewards_from_fn, '==get_rewards_from_fn==', RM_TYPE)
+
+
+class CustomPPOTrainer(PPOTrainer, Trainer):
+    r"""
+    Inherits PPOTrainer.
+    """
+
+    def __init__(
+        self,
+        model_args: "ModelArguments",
+        training_args: "Seq2SeqTrainingArguments",
+        finetuning_args: "FinetuningArguments",
+        generating_args: "GeneratingArguments",
+        callbacks: Optional[List["TrainerCallback"]],
+        model: "AutoModelForCausalLMWithValueHead",
+        reward_model: Optional["AutoModelForCausalLMWithValueHead"],
+        ref_model: Optional["AutoModelForCausalLMWithValueHead"],
+        tokenizer: "PreTrainedTokenizer",
+        processor: Optional["ProcessorMixin"],
+        dataset: "Dataset",
+        data_collator: "DataCollatorWithPadding"
+    ) -> None:
+        # if eval_dataset is not None:
+        #     raise NotImplementedError("PPOTrainer does not support eval dataset yet.")
+
+        self.training_args = training_args
+        print(self.training_args, '===training_args===')
+        backward_batch_size = training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps
+        ppo_config = PPOConfig(
+            gradient_checkpointing=training_args.gradient_checkpointing,
+            model_name=model_args.model_name_or_path,
+            learning_rate=training_args.learning_rate,
+            mini_batch_size=training_args.per_device_train_batch_size,
+            batch_size=backward_batch_size * finetuning_args.ppo_buffer_size,
+            gradient_accumulation_steps=training_args.gradient_accumulation_steps,
+            ppo_epochs=finetuning_args.ppo_epochs,
+            max_grad_norm=training_args.max_grad_norm,
+            seed=training_args.seed,
+            optimize_device_cache=True,
+            target=finetuning_args.ppo_target,
+            lam=training_args.lam,
+            whiten_advantages=training_args.ppo_whiten_advantages,
+            init_kl_coef=training_args.init_kl_coef,
+            adap_kl_ctrl=training_args.adap_kl_ctrl,
+            kl_penalty=training_args.kl_penalty,
+            use_score_scaling=finetuning_args.ppo_score_norm,
+            use_score_norm=finetuning_args.ppo_score_norm,
+            whiten_rewards=finetuning_args.ppo_whiten_rewards,
+            accelerator_kwargs={"step_scheduler_with_optimizer": True},
+            log_with='tensorboard',
+            project_kwargs={"logging_dir": training_args.logging_dir},
+        )
+        
+        logger.info("####training_args####")
+        logger.info(training_args)
+        
+        logger.info("####ppo_config####")
+        logger.info(ppo_config)
+        
+        # Create optimizer and scheduler
+        if training_args.max_steps > 0:
+            num_training_steps = training_args.max_steps
+        else:
+            total_train_batch_size = backward_batch_size * finetuning_args.ppo_buffer_size * training_args.world_size
+            num_training_steps = training_args.num_train_epochs * math.ceil(
+                len(dataset) / total_train_batch_size
+            )
+
+        # Add deepspeed config
+        if training_args.deepspeed_plugin is not None:
+            ppo_config.accelerator_kwargs["kwargs_handlers"] = [
+                DistributedDataParallelKwargs(find_unused_parameters=training_args.ddp_find_unused_parameters)
+            ]
+            
+            self.propagate_args_to_deepspeed()
+            
+            hf_deepspeed_config = training_args.deepspeed_plugin.hf_ds_config
+            hf_deepspeed_config.trainer_config_finalize(self.training_args, 
+                                                        model, num_training_steps)
+            
+            logger.info("####trainer_config_finalize####")
+            logger.info(hf_deepspeed_config.config)
+            
+            logger.info("####ppo_config.log_with####")
+            logger.info(ppo_config.log_with)
+            
+            ppo_config.accelerator_kwargs["deepspeed_plugin"] = training_args.deepspeed_plugin
+            # if ppo_config.log_with is not None:
+            #     logger.warning("PPOTrainer cannot use external logger when DeepSpeed is enabled.")
+            #     ppo_config.log_with = None
+        
+        model_parameters = list(filter(lambda p: p.requires_grad, model.parameters()))
+        if "optimizer" in hf_deepspeed_config.config:
+            optimizer = DummyOptim(params=model_parameters)
+            logger.info('###optimizer in hf_deepspeed_config###')
+            logger.info(optimizer)
+        else:
+            optimizer = self.create_optimizer(model, training_args, finetuning_args)
+            hf_deepspeed_config.config["zero_allow_untested_optimizer"] = True
+            
+        if "scheduler" in hf_deepspeed_config.config:
+            scheduler = DummyScheduler(optimizer)
+            logger.info('###scheduler in hf_deepspeed_config###')
+            logger.info(scheduler)
+        else:
+            if isinstance(optimizer, DummyOptim):
+                def _lr_scheduler_callable(optimizer):
+                    # create a shallow copy first, so later modifications do not affect original trainer
+                    trainer_copy = copy.copy(self)
+                    # at the time _lr_scheduler_callable is called, trainer.lr_scheduler has been set
+                    # update it to None so that we can re-create a new scheduler
+                    trainer_copy.lr_scheduler = None
+                    lr_scheduler = trainer_copy.create_scheduler(
+                        training_args=training_args,
+                        num_training_steps=num_training_steps, optimizer=optimizer
+                    )
+                    logger.info('###lr_scheduler in _lr_scheduler_callable###')
+                    logger.info(lr_scheduler)
+                    return lr_scheduler
+                scheduler = DummyScheduler(optimizer, lr_scheduler_callable=_lr_scheduler_callable)
+            else:
+                scheduler = self.create_scheduler(training_args, num_training_steps, optimizer)
+                
+        logger.info("#####optimizer#####")
+        logger.info(optimizer)
+        logger.info("#####scheduler#####")
+        logger.info(scheduler)
+        
+        dist.barrier()
+        disable_dropout_in_model(model)
+        disable_dropout_in_model(ref_model)
+
+        PPOTrainer.__init__(
+            self,
+            training_args=training_args,
+            config=ppo_config,
+            model=model,
+            ref_model=ref_model,
+            tokenizer=tokenizer,
+            dataset=dataset,
+            optimizer=optimizer,
+            data_collator=data_collator,
+            lr_scheduler=scheduler,
+            num_training_steps=num_training_steps
+        )
+        
+        dist.barrier()
+
+        self.args = training_args
+        self.model_args = model_args
+        self.finetuning_args = finetuning_args
+        self.reward_model = reward_model
+        self.current_device = get_current_device()  # patch for deepspeed training
+
+        self.generation_config = GenerationConfig(
+            pad_token_id=self.tokenizer.pad_token_id,
+            eos_token_id=[self.tokenizer.eos_token_id] + self.tokenizer.additional_special_tokens_ids,
+            **generating_args.to_dict(),
+        )
+
+        self.state = TrainerState()
+        self.control = TrainerControl()
+        self.is_deepspeed_enabled = getattr(self.accelerator.state, "deepspeed_plugin", None) is not None
+        self.is_fsdp_enabled = getattr(self.accelerator.state, "fsdp_plugin", None) is not None
+        callbacks = DEFAULT_CALLBACKS if callbacks is None else DEFAULT_CALLBACKS + callbacks
+        self.callback_handler = CallbackHandler(
+            callbacks, self.accelerator.unwrap_model(self.model), self.tokenizer, self.optimizer, self.lr_scheduler
+        )
+        if self.args.max_steps > 0:
+            logger.info("max_steps is given, it will override any value given in num_train_epochs")
+
+        self.amp_context = torch.autocast(self.current_device.type)
+        warnings.simplefilter("ignore")  # remove gc warnings on ref model
+
+        if finetuning_args.reward_model_type == "full":
+            if self.is_deepspeed_enabled:
+                if not (
+                    getattr(reward_model.pretrained_model, "is_loaded_in_8bit", False)
+                    or getattr(reward_model.pretrained_model, "is_loaded_in_4bit", False)
+                ):  # quantized models are already set on the correct device
+                    self.reward_model = self._prepare_deepspeed(self.reward_model)
+            else:
+                self.reward_model = self.accelerator.prepare_model(self.reward_model, evaluation_mode=True)
+
+        self.add_callback(FixValueHeadModelCallback)
+        
+        dist.barrier()
+
+        if processor is not None:
+            self.add_callback(SaveProcessorCallback(processor))
+
+        if finetuning_args.use_badam:
+            from badam import BAdamCallback, clip_grad_norm_old_version
+
+            self.accelerator.clip_grad_norm_ = MethodType(clip_grad_norm_old_version, self.accelerator)
+            self.add_callback(BAdamCallback)
+            
+
+    def ppo_train(self, resume_from_checkpoint: Optional[str] = None) -> None:
+        r"""
+        Implements training loop for the PPO stage, like _inner_training_loop() in Huggingface's Trainer.
+        """
+        if resume_from_checkpoint is not None:
+            raise ValueError("`resume_from_checkpoint` will be supported in the future version.")
+
+        total_train_batch_size = (
+            self.args.per_device_train_batch_size
+            * self.args.gradient_accumulation_steps
+            * self.finetuning_args.ppo_buffer_size
+            * self.args.world_size
+        )
+        if self.args.max_steps > 0:
+            num_examples = total_train_batch_size * self.args.max_steps
+            num_train_epochs = sys.maxsize
+            max_steps = self.args.max_steps
+            steps_in_epoch = self.args.max_steps
+        else:
+            len_dataloader = len(self.dataloader)
+            num_examples = len(self.dataset)
+            num_train_epochs = self.args.num_train_epochs
+            max_steps = math.ceil(num_train_epochs * len_dataloader)
+            steps_in_epoch = len_dataloader
+
+        self.state.max_steps = max_steps
+        self.state.num_train_epochs = num_train_epochs
+        self.state.is_local_process_zero = self.is_local_process_zero()
+        self.state.is_world_process_zero = self.is_world_process_zero()
+
+        if self.is_world_process_zero():
+            logger.info("***** Running training *****")
+            logger.info("  Num examples = {:,}".format(num_examples))
+            logger.info("  Num Epochs = {:,}".format(num_train_epochs))
+            logger.info("  Instantaneous batch size per device = {:,}".format(self.args.per_device_train_batch_size))
+            logger.info(
+                "  Total train batch size (w. parallel, buffer, distributed & accumulation) = {:,}".format(
+                    total_train_batch_size
+                )
+            )
+            logger.info("  Gradient Accumulation steps = {:,}".format(self.args.gradient_accumulation_steps))
+            logger.info("  Num optimization epochs per batch = {:,}".format(self.finetuning_args.ppo_epochs))
+            logger.info("  Total training steps = {:,}".format(max_steps))
+            logger.info("  Number of trainable parameters = {:,}".format(count_parameters(self.model)[0]))
+            
+        if self.is_world_process_zero():
+            self.writer = iSummaryWriter(
+                    log_path=os.path.join(self.args.logging_dir, 'my_log'), 
+                    log_name='step_dpo')
+            logger.info("#######iSummaryWriter#######")
+
+        dataiter = iter(self.dataloader)
+        loss_meter = AverageMeter()
+        reward_meter = AverageMeter()
+        gold_reward_meter = AverageMeter()
+        self.callback_handler.on_train_begin(self.args, self.state, self.control)
+
+        for step in tqdm(range(max_steps), disable=not self.is_local_process_zero()):
+            try:
+                batch = next(dataiter)
+            except StopIteration:
+                dataiter = iter(self.dataloader)
+                batch = next(dataiter)
+                
+            dist.barrier()
+
+            # Get inputs
+            self.model.eval()
+            self.tokenizer.padding_side = "right"  # change padding side
+            queries, responses, rewards = [], [], []
+            for idx in range(0, self.config.batch_size, self.config.mini_batch_size):
+                mini_batch_queries, mini_batch_responses = self.get_inputs(
+                    batch[idx : idx + self.config.mini_batch_size]
+                )
+                mini_batch_rewards = self.get_rewards(mini_batch_queries, mini_batch_responses)
+                queries.extend(mini_batch_queries)
+                responses.extend(mini_batch_responses)
+                rewards.extend(mini_batch_rewards)
+                
+            if self.is_world_process_zero():
+                logger.info("#######queries#######")
+                logger.info(self.tokenizer.batch_decode(queries, skip_special_tokens=False)[0])
+                logger.info("#######responses#######")
+                logger.info(self.tokenizer.batch_decode(responses, skip_special_tokens=False)[0])
+                logger.info("#######rewards#######")
+                logger.info(rewards)
+                
+            dist.barrier()
+            logger.info("#######begin ppo-step#######")
+
+            # Run PPO step
+            self.model.train()
+            # with torch.autocast(device_type='cuda'):
+            with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+                stats = self.step(queries, responses, rewards)
+                
+            # stats = self.step(queries, responses, rewards)
+            
+            logger.info("#######end ppo-step#######")
+            
+            self.tokenizer.padding_side = "left"  # restore padding side
+            loss_meter.update(float(stats["ppo/loss/total"]), n=len(rewards))
+            reward_meter.update(torch.stack(rewards).mean().item(), n=len(rewards))
+            
+            logger.info("#######log_with#######")
+            logger.info(self.config.log_with)
+
+            gold_rewards = None
+            if self.config.log_with is not None:
+                try:
+                    batch["query"] = self.tokenizer.batch_decode(queries, skip_special_tokens=True)
+                    batch["response"] = self.tokenizer.batch_decode(responses, skip_special_tokens=True)
+                    gold_rewards = get_rewards_from_rule(batch["query"], 
+                                          batch["response"])
+                    gold_reward_meter.update(gold_rewards.mean().cpu().numpy().item(), n=len(gold_rewards))
+                    self.log_stats(stats, batch, rewards)
+                except Exception:
+                    gold_rewards = None
+                    logger.warning("Failed to save stats due to unknown errors.")
+                    
+            if self.is_world_process_zero():
+                logger.info("#######begin ppo-info-log#######")
+                for key in stats:
+                    if key in ['ppo/loss/policy', 'ppo/loss/value',
+                           'ppo/loss/total', 'ppo/policy/entropy',
+                           'ppo/policy/policykl']:
+                        self.writer.add_scalar(key, 
+                                        np.mean(stats[key]).item(), 
+                                        self.state.global_step)
+                self.writer.add_scalar('env/reward_mean',
+                                       torch.mean(torch.tensor(rewards)).cpu().numpy().item(),
+                                      self.state.global_step)
+                if gold_rewards is not None:
+                    self.writer.add_scalar('env/gold_reward_mean',
+                                       torch.mean(torch.tensor(gold_rewards)).cpu().numpy().item(),
+                                      self.state.global_step)
+                self.writer.record()
+                logger.info("#######end ppo-info-log#######")
+
+            self.state.global_step += 1
+            self.callback_handler.on_step_end(self.args, self.state, self.control)
+
+            if self.is_local_process_zero() and (step + 1) % self.args.logging_steps == 0:
+                logger.info("#######begin info-log#######")
+                logs = dict(
+                    loss=round(loss_meter.avg, 4),
+                    reward=round(reward_meter.avg, 4),
+                    learning_rate=stats["ppo/learning_rate"],
+                    learning_rate_optimizer=stats["ppo/learning_rate_optimizer"],
+                    clipfrac=float(np.mean(stats["ppo/policy/clipfrac"])),
+                    advantages_mean=float(np.mean(stats["ppo/policy/advantages_mean"])),
+                    entropy=float(np.mean(stats["ppo/policy/entropy"])),
+                    val_error=float(np.mean(stats["ppo/val/error"])),
+                    approxkl=float(np.mean(stats["ppo/policy/approxkl"])),
+                    policykl=float(np.mean(stats["ppo/policy/policykl"])),
+                    value_loss=float(np.mean(stats["ppo/loss/value"])),
+                    kl_coef=float(np.mean(stats["objective/kl_coef"])),
+                    objective_kl=float(np.mean(stats["objective/kl"])),
+                    pg_loss=float(np.mean(stats["ppo/loss/policy"])),
+                    epoch=round(step / steps_in_epoch, 2),
+                    gold_reward_meter=round(gold_reward_meter.avg, 4),
+                )
+                tqdm.write(str(logs))
+                logs["step"] = step
+                self.state.log_history.append(logs)
+                self.callback_handler.on_log(self.args, self.state, self.control, logs)
+                loss_meter.reset()
+                reward_meter.reset()
+
+            if (step + 1) % self.args.save_steps == 0:  # save checkpoint
+                self.save_model(
+                    os.path.join(self.args.output_dir, "{}-{}".format(PREFIX_CHECKPOINT_DIR, self.state.global_step))
+                )
+                self.callback_handler.on_save(self.args, self.state, self.control)
+
+            if self.control.should_epoch_stop or self.control.should_training_stop:
+                break
+
+        self.callback_handler.on_train_end(self.args, self.state, self.control)
+
+    @override
+    def create_optimizer(
+        self,
+        model: "AutoModelForCausalLMWithValueHead",
+        training_args: "Seq2SeqTrainingArguments",
+        finetuning_args: "FinetuningArguments",
+    ) -> "torch.optim.Optimizer":
+        optimizer = create_custom_optimizer(model, training_args, finetuning_args)
+        if optimizer is None:
+            decay_params, nodecay_params = [], []
+            decay_param_names = self.get_decay_parameter_names(model)
+            for name, param in model.named_parameters():
+                if param.requires_grad:
+                    if name in decay_param_names:
+                        decay_params.append(param)
+                    else:
+                        nodecay_params.append(param)
+
+            optim_class, optim_kwargs = Trainer.get_optimizer_cls_and_kwargs(training_args)
+            param_groups = [
+                dict(params=nodecay_params, weight_decay=0.0),
+                dict(params=decay_params, weight_decay=training_args.weight_decay),
+            ]
+            optimizer = optim_class(param_groups, **optim_kwargs)
+            logger.info('#######optimizer######')
+            logger.info(optim_class)
+            logger.info('#######optim_kwargs######')
+            logger.info(optim_kwargs)
+
+        return optimizer
+
+    @override
+    def create_scheduler(
+        self, training_args: "Seq2SeqTrainingArguments", num_training_steps: int, optimizer: "torch.optim.Optimizer"
+    ) -> "torch.optim.lr_scheduler.LRScheduler":
+        # create_custom_scheduler(training_args, num_training_steps, optimizer)
+        lr_scheduler = get_scheduler(
+            training_args.lr_scheduler_type,
+            optimizer=optimizer,
+            num_warmup_steps=training_args.get_warmup_steps(num_training_steps),
+            num_training_steps=num_training_steps,
+        )
+        return lr_scheduler
+
+    @torch.no_grad()
+    def get_inputs(self, batch: Dict[str, "torch.Tensor"]) -> Tuple[List["torch.Tensor"], List["torch.Tensor"]]:
+        r"""
+        Generates model's responses given queries.
+        """
+        if batch["input_ids"].size(0) == 1:  # handle llama2 ppo with gradient accumulation > 1
+            start_index = (batch["input_ids"][0] != self.tokenizer.pad_token_id).nonzero()[0].item()
+            for k, v in batch.items():
+                batch[k] = v[:, start_index:]
+
+        with unwrap_model_for_generation(self.model, self.accelerator) as unwrapped_model:
+            unwrapped_model: "AutoModelForCausalLMWithValueHead" = self.accelerator.unwrap_model(self.model)
+            if self.model_args.upcast_layernorm:
+                layernorm_params = dump_layernorm(unwrapped_model)
+
+            generate_output: "torch.Tensor" = unwrapped_model.generate(
+                generation_config=self.generation_config, logits_processor=get_logits_processor(),
+                input_ids=batch['input_ids']
+            )
+            if self.model_args.upcast_layernorm:
+                restore_layernorm(unwrapped_model, layernorm_params)
+
+        query = batch["input_ids"].detach().cpu()
+        response = generate_output[:, batch["input_ids"].size(-1) :].detach().cpu()
+        queries, responses = [], []
+        for i in range(len(query)):
+            query_start_index = (query[i] != self.tokenizer.pad_token_id).nonzero()[0].item()
+            response_indexes = (response[i] != self.tokenizer.pad_token_id).nonzero()
+
+            if len(response_indexes) == 0:  # allow empty response
+                response_length = 1
+            elif self.tokenizer.eos_token_id == self.tokenizer.pad_token_id:  # include eos token
+                response_length = response_indexes[-1].item() + 2
+            else:
+                response_length = response_indexes[-1].item() + 1
+
+            queries.append(query[i, query_start_index:])  # remove padding from left
+            responses.append(response[i, :response_length])  # remove padding from right
+
+        return queries, responses
+
+    @torch.no_grad()
+    def get_rewards(
+        self,
+        queries: List["torch.Tensor"],
+        responses: List["torch.Tensor"],
+        **kwargs
+    ) -> List["torch.Tensor"]:
+        r"""
+        Computes scores using given reward model.
+
+        Both inputs and outputs are put on CPU.
+        """
+        if self.finetuning_args.reward_model_type == "api":
+            query_messages = self.tokenizer.batch_decode(queries, 
+                                                    skip_special_tokens=True)
+            response_messages = self.tokenizer.batch_decode(responses, 
+                                                    skip_special_tokens=True)
+            if 'mini_batch_answers' in kwargs:
+                mini_batch_answers = kwargs['mini_batch_answers'].detach().cpu()
+                answer_messages = self.tokenizer.batch_decode(mini_batch_answers, 
+                skip_special_tokens=True)
+                return get_rewards_from_fn(query_messages, 
+                                           response_messages,
+                                          answers=answer_messages)
+            else:
+                return get_rewards_from_fn(query_messages, 
+                                            response_messages)
+
+        batch: Dict[str, "torch.Tensor"] = self.prepare_model_inputs(queries, responses)
+        unwrapped_model: "AutoModelForCausalLMWithValueHead" = self.accelerator.unwrap_model(self.model)
+
+        if self.finetuning_args.reward_model_type == "lora":
+            replace_model(unwrapped_model, target="reward")
+            reward_model = self.model
+        else:
+            reward_model = self.reward_model
+
+        with unwrap_model_for_generation(reward_model, self.accelerator), self.amp_context:  # support bf16
+            values: "torch.Tensor" = reward_model(**batch, return_dict=True, use_cache=False)[-1]
+
+        if self.finetuning_args.reward_model_type == "lora":
+            replace_model(unwrapped_model, target="default")
+
+        rewards = values.gather(dim=-1, index=(batch["attention_mask"].sum(dim=-1, keepdim=True) - 1))
+        return rewards.float().detach()  # use fp32 type
+
+    @override
+    @PPODecorators.empty_device_cache()
+    def batched_forward_pass(
+        self,
+        model: "AutoModelForCausalLMWithValueHead",
+        queries: "torch.Tensor",
+        responses: "torch.Tensor",
+        model_inputs: Dict[str, Any],
+        return_logits: bool = False,
+        response_masks: Optional["torch.Tensor"] = None,
+    ) -> Tuple["torch.Tensor", Optional["torch.Tensor"], "torch.Tensor", "torch.Tensor"]:
+        r"""
+        Calculates model outputs in multiple batches.
+
+        Subclass and override to inject custom behavior.
+        """
+        bs = len(queries)
+        fbs = self.config.mini_batch_size
+        all_logprobs = []
+        all_logits = []
+        all_masks = []
+        all_values = []
+
+        for i in range(math.ceil(bs / fbs)):
+            input_kwargs = {key: value[i * fbs : (i + 1) * fbs] for key, value in model_inputs.items()}
+            query_batch = queries[i * fbs : (i + 1) * fbs]
+            response_batch = responses[i * fbs : (i + 1) * fbs]
+            if response_masks is not None:
+                response_masks_batch = response_masks[i * fbs : (i + 1) * fbs]
+            input_ids = input_kwargs["input_ids"]
+            attention_mask = input_kwargs["attention_mask"]
+
+            with self.amp_context:  # support bf16
+                logits, _, values = model(**input_kwargs, return_dict=True, use_cache=False)
+
+            logprobs = logprobs_from_logits(logits[:, :-1, :], input_ids[:, 1:])
+            masks = torch.zeros_like(attention_mask)
+            masks[:, :-1] = attention_mask[:, 1:]
+
+            for j in range(len(query_batch)):
+                start = len(query_batch[j]) - 1
+                if attention_mask[j, 0] == 0:  # offset left padding
+                    start += attention_mask[j, :].nonzero()[0].item()
+                end = start + len(response_batch[j])
+
+                if response_masks is not None:
+                    response_masks_batch = torch.cat((torch.zeros_like(query_batch[j]), response_masks_batch[j]))[1:]
+
+                masks[j, :start] = 0
+                masks[j, end:] = 0
+                if response_masks is not None:
+                    masks[j, start:end] = masks[j, start:end] * response_masks_batch[j][start:end]
+
+            if return_logits:
+                all_logits.append(logits)
+            else:
+                del logits
+
+            all_values.append(values)
+            all_logprobs.append(logprobs)
+            all_masks.append(masks)
+
+        return (
+            torch.cat(all_logprobs),
+            torch.cat(all_logits)[:, :-1] if return_logits else None,
+            torch.cat(all_values)[:, :-1],
+            torch.cat(all_masks)[:, :-1],
+        )
+
+    @override
+    def save_model(self, output_dir: Optional[str] = None) -> None:
+        r"""
+        Saves model checkpoint.
+
+        Subclass and override to inject custom behavior.
+        """
+        if output_dir is None:
+            output_dir = self.args.output_dir
+
+        if self.is_fsdp_enabled or self.is_deepspeed_enabled:
+            try:
+                state_dict = self.accelerator.get_state_dict(self.model)  # must be called at all ranks
+                if self.args.should_save:
+                    self._save(output_dir, state_dict=state_dict)
+            except ValueError:
+                logger.warning(
+                    " stage3_gather_16bit_weights_on_model_save=false. Saving the full checkpoint instead,"
+                    " use zero_to_fp32.py to recover weights"
+                )
+                if self.args.should_save:
+                    self._save(output_dir, state_dict={})
+                # remove the dummy state_dict
+                remove_dummy_checkpoint(self.args.should_save, output_dir, [WEIGHTS_NAME, SAFE_WEIGHTS_NAME])
+                self.model.save_checkpoint(output_dir)
+
+        elif self.args.should_save:
+            unwrapped_model: "AutoModelForCausalLMWithValueHead" = self.accelerator.unwrap_model(self.model)
+            self._save(output_dir, state_dict=unwrapped_model.state_dict())
+            
+    def propagate_args_to_deepspeed(self, auto_find_batch_size=False):
+        """
+        Sets values in the deepspeed plugin based on the Trainer args
+        """
+        from transformers.integrations.deepspeed import HfTrainerDeepSpeedConfig
+
+        ds_plugin = self.training_args.deepspeed_plugin
+
+        ds_plugin.hf_ds_config = HfTrainerDeepSpeedConfig(ds_plugin.hf_ds_config.config)
+        ds_plugin.deepspeed_config = ds_plugin.hf_ds_config.config
+        ds_plugin.hf_ds_config.trainer_config_process(self.training_args, auto_find_batch_size)
+        
+        logger.info("####trainer_config_process####")
+        logger.info(self.training_args.deepspeed_plugin.deepspeed_config)

ppo_trainer.py

@@ -0,0 +1,1646 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import inspect
+import math
+import json
+import os
+import time
+import typing
+import warnings
+import copy
+from contextlib import nullcontext
+from typing import Callable, List, Optional, Union
+from transformers.optimization import get_scheduler
+
+import datasets
+import numpy as np
+import torch
+import torch.nn.functional as F
+from accelerate import Accelerator
+from accelerate.utils import ProjectConfiguration, gather_object, is_deepspeed_available
+from datasets import Dataset
+from huggingface_hub import whoami
+from packaging import version
+from torch.optim import Adam
+from transformers import (
+    DataCollatorForLanguageModeling,
+    PreTrainedTokenizer,
+    PreTrainedTokenizerBase,
+    PreTrainedTokenizerFast,
+)
+
+from trl.core import (
+    WANDB_PADDING,
+    PPODecorators,
+    clip_by_value,
+    convert_to_scalar,
+    entropy_from_logits,
+    flatten_dict,
+    logprobs_from_logits,
+    masked_mean,
+    masked_var,
+    masked_whiten,
+    set_seed,
+    stack_dicts,
+    stats_to_np,
+)
+from trl.import_utils import is_npu_available, is_torch_greater_2_0, is_xpu_available
+from trl.models import (
+    SUPPORTED_ARCHITECTURES,
+    PreTrainedModelWrapper,
+    create_reference_model,
+    unwrap_model_for_generation,
+)
+from trl.trainer import AdaptiveKLController, BaseTrainer, FixedKLController, RunningMoments
+from my_ppo_config import PPOConfig
+from transformers.trainer_pt_utils import _get_learning_rate
+
+if is_deepspeed_available():
+    import deepspeed
+    
+import logging
+
+from accelerate.state import AcceleratorState
+from accelerate.utils import DeepSpeedOptimizerWrapper
+from transformers import (
+        DataCollatorWithPadding,
+        PreTrainedTokenizer,
+        ProcessorMixin,
+        Seq2SeqTrainingArguments,
+        TrainerCallback,
+    )
+
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+MODEL_CARD_TEMPLATE = """---
+license: apache-2.0
+library_name: transformers
+tags:
+- trl
+- ppo
+- transformers
+- reinforcement-learning
+---
+
+# {model_name}
+
+This is a [TRL language model](https://github.com/huggingface/trl) that has been fine-tuned with reinforcement learning to
+ guide the model outputs according to a value, function, or human feedback. The model can be used for text generation.
+
+## Usage
+
+To use this model for inference, first install the TRL library:
+
+```bash
+python -m pip install trl
+```
+
+You can then generate text as follows:
+
+```python
+from transformers import pipeline
+
+generator = pipeline("text-generation", model="{model_id}")
+outputs = generator("Hello, my llama is cute")
+```
+
+If you want to use the model for training or to obtain the outputs from the value head, load the model as follows:
+
+```python
+from transformers import AutoTokenizer
+from trl import AutoModelForCausalLMWithValueHead
+
+tokenizer = AutoTokenizer.from_pretrained("{model_id}")
+model = AutoModelForCausalLMWithValueHead.from_pretrained("{model_id}")
+
+inputs = tokenizer("Hello, my llama is cute", return_tensors="pt")
+outputs = model(**inputs, labels=inputs["input_ids"])
+```
+"""
+
+def get_eval_ds_config(deepspeed_states, offload=None, stage=3):
+    deepspeed_states = AcceleratorState().deepspeed_plugin
+
+    device = "cpu" if offload else "none"
+    zero_opt_dict = {
+        "stage": stage,
+        "stage3_param_persistence_threshold": 1e4,
+        "offload_param": {
+            "device": device
+        }
+    }
+    return {
+        "train_micro_batch_size_per_gpu": deepspeed_states.deepspeed_config['train_micro_batch_size_per_gpu'],
+        "steps_per_print": 10,
+        "zero_optimization": zero_opt_dict,
+        "bf16": {
+            "enabled": True
+        },
+        "gradient_clipping": 1.0,
+        "prescale_gradients": False,
+        "wall_clock_breakdown": False
+    }
+
+
+class PPOTrainer(BaseTrainer):
+    """
+    The PPOTrainer uses Proximal Policy Optimization to optimise language models.
+    Note, this trainer is heavily inspired by the original OpenAI learning to summarize work here:
+    https://github.com/openai/summarize-from-feedback
+
+    Attributes:
+        **config** (`PPOConfig`) -- Configuration object for PPOTrainer. Check the documentation of `PPOConfig` for more
+            details.
+        **model** (`PreTrainedModelWrapper`) -- Model to be optimized, Hugging Face transformer model with a value head.
+            Check the documentation of `PreTrainedModelWrapper` for more details.
+        **ref_model** (`PreTrainedModelWrapper`, *optional*) -- Reference model to be used for KL penalty, Hugging Face
+            transformer model with a casual language modelling head. Check the documentation of `PreTrainedModelWrapper`
+            for more details. If no reference model is provided, the trainer will create a reference model with the same
+             architecture as the model to be optimized with shared layers.
+        **tokenizer** (`PreTrainedTokenizerBase`) -- Tokenizer to be used for encoding the
+            data. Check the documentation of `transformers.PreTrainedTokenizer` and
+            `transformers.PreTrainedTokenizerFast` for more details.
+        **dataset** (Union[`torch.utils.data.Dataset`, `datasets.Dataset`], *optional*) -- PyTorch dataset or Hugging
+            Face dataset. This is used to create a PyTorch dataloader. If no dataset is provided, the dataloader must be
+             created outside the trainer users needs to design their own dataloader and make sure the batch
+            size that is used is the same as the one specified in the configuration object.
+        **optimizer** (`torch.optim.Optimizer`, *optional*) -- Optimizer to be used for training. If no optimizer is
+            provided, the trainer will create an Adam optimizer with the learning rate specified in the configuration
+            object.
+        **data_collator** (DataCollatorForLanguageModeling, *optional*) -- Data collator to be used for training and
+            passed along the dataloader
+        **num_shared_layers** (int, *optional*) -- Number of layers to be shared between the model and the reference
+            model, if no reference model is passed. If no number is provided, all the layers will be shared.
+        **lr_scheduler** (`torch.optim.lr_scheduler`, *optional*) -- Learning rate scheduler to be used for training.
+    """
+
+    _tag_names = ["trl", "ppo"]
+
+    def __init__(
+        self,
+        training_args: Optional[Seq2SeqTrainingArguments] = None,
+        config: Optional[PPOConfig] = None,
+        model: Optional[PreTrainedModelWrapper] = None,
+        ref_model: Optional[PreTrainedModelWrapper] = None,
+        tokenizer: Optional[PreTrainedTokenizerBase] = None,
+        dataset: Optional[Union[torch.utils.data.Dataset, Dataset]] = None,
+        optimizer: Optional[torch.optim.Optimizer] = None,
+        data_collator: Optional[typing.Callable] = None,
+        num_shared_layers: Optional[int] = None,
+        lr_scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+        training_data_collator: Optional[typing.Callable] = None,
+        num_training_steps: Optional[int] = None
+    ):
+        """
+        Initialize PPOTrainer.
+
+        Args:
+            config (`PPOConfig`):
+                Configuration object for PPOTrainer. Check the documentation of `PPOConfig` for more details.
+            model (`PreTrainedModelWrapper`):
+                Hugging Face transformer model with a value head.
+            ref_model (`PreTrainedModelWrapper`):
+                Hugging Face transformer model with a casual language modelling head. Used for KL penalty
+            tokenizer (`transformers.PreTrainedTokenizerBase`):
+                Hugging Face tokenizer
+            dataset (Optional[Union[`torch.utils.data.Dataset`, `datasets.Dataset`]]):
+                PyTorch dataset or Hugging Face dataset. If a Hugging Face dataset is passed, the dataset
+                will be preprocessed by removing the columns that are not used by the model. If none is passed,
+                a warning will be raised in a multi-GPU setting.
+            optimizer (`Optional[torch.optim.Optimizer]`):
+                Optimizer used for training. If `None`, the `Adam` is used as default.
+            data_collator (Optional[function]):
+                Data collator function that is going to be used for `prepare_dataloader` method. Note this collator
+                is different from the one we use for training. Pass a valid `training_data_collator` instead.
+            num_shared_layers (Optional[int]):
+                Number of shared layers between the model and the reference model. If `None`, all layers are shared.
+                used only if `ref_model` is `None`.
+            lr_scheduler (`Optional[torch.optim.lr_scheduler]`):
+                Learning rate scheduler used for training.
+            training_data_collator (Optional[function]):
+                Custom data collator used for training.
+        """
+        warnings.warn(
+            "`PPOTrainer` is deprecated and will be removed in trl v0.12. Please use `PPOv2Trainer` instead.",
+            FutureWarning,
+        )
+        super().__init__(config)
+
+        # initial seed for reproducible experiments
+        set_seed(config.seed)
+        self.training_args = training_args
+        self.num_training_steps = num_training_steps
+
+        # Step 0: check positional arguments validity
+        if not isinstance(config, PPOConfig):
+            raise ValueError(f"config must be a PPOConfig, got {type(config)}")
+        if not isinstance(tokenizer, (PreTrainedTokenizerBase)):
+            raise ValueError(
+                f"tokenizer must be a PreTrainedTokenizerBase like a PreTrainedTokenizer or a PreTrainedTokenizerFast, got {type(tokenizer)}"
+            )
+        if not isinstance(model, (SUPPORTED_ARCHITECTURES)):
+            raise ValueError(
+                f"model must be a PreTrainedModelWrapper, got {type(model)} - supported architectures are: {SUPPORTED_ARCHITECTURES}"
+            )
+        # Step 1: Initialize Accelerator
+        self.accelerator = Accelerator(
+            log_with=config.log_with,
+            gradient_accumulation_steps=config.gradient_accumulation_steps,
+            project_config=ProjectConfiguration(**config.project_kwargs),
+            **config.accelerator_kwargs,
+        )
+        
+        logger.info("##step_scheduler_with_optimizer##")
+        logger.info(self.accelerator.step_scheduler_with_optimizer)
+        
+        logger.info("###distributed_type###")
+        logger.info(self.accelerator.distributed_type)
+        
+        self.is_deepspeed_enabled = getattr(self.accelerator.state, "deepspeed_plugin", None) is not None
+        if self.is_deepspeed_enabled and getattr(self.training_args, "hf_deepspeed_config", None) is None:
+            self.propagate_args_to_deepspeed()
+
+        # Step 1.1 Runtime variables filled by the accelerator
+        config.world_size = self.accelerator.num_processes
+        config.global_backward_batch_size = config.backward_batch_size * config.world_size
+        config.global_batch_size = config.batch_size * config.world_size
+
+        self.model = model
+        self.model_params = filter(lambda p: p.requires_grad, self.model.parameters())
+        self.is_encoder_decoder = hasattr(self.model, "is_encoder_decoder")
+        self.is_peft_model = getattr(self.model, "is_peft_model", False)
+        config.is_encoder_decoder = self.is_encoder_decoder
+        config.is_peft_model = self.is_peft_model
+
+        is_using_tensorboard = config.log_with is not None and config.log_with == "tensorboard"
+        # self.accelerator.init_trackers(
+        #     config.tracker_project_name,
+        #     config=dict(trl_ppo_trainer_config=config.to_dict()) if not is_using_tensorboard else config.to_dict(),
+        #     init_kwargs=config.tracker_kwargs,
+        # )
+        self.is_using_text_environment = getattr(config, "use_text_environment", False)
+
+        if isinstance(ref_model, SUPPORTED_ARCHITECTURES):
+            self.ref_model = ref_model
+            if num_shared_layers is not None:
+                warnings.warn(
+                    "num_shared_layers is ignored when ref_model is provided. Two different models are used for the "
+                    "model and the reference model and no layers are shared.",
+                    UserWarning,
+                )
+        elif ref_model is None and not self.is_peft_model:
+            self.ref_model = create_reference_model(self.model, num_shared_layers=num_shared_layers)
+        elif self.is_peft_model:
+            self.ref_model = None
+        else:
+            raise ValueError(
+                f"ref_model must be a PreTrainedModelWrapper or `None`, got {type(ref_model)} - supported "
+                f"architectures are: {SUPPORTED_ARCHITECTURES} "
+            )
+        self.optional_peft_ctx = (
+            self.accelerator.unwrap_model(self.model).pretrained_model.disable_adapter
+            if self.is_peft_model
+            else nullcontext
+        )
+
+        if not (isinstance(tokenizer, PreTrainedTokenizer) or isinstance(tokenizer, PreTrainedTokenizerFast)):
+            raise ValueError(
+                "tokenizer must be a transformers.PreTrainedTokenizer or transformers.PreTrainedTokenizerFast"
+            )
+        self.tokenizer = tokenizer
+
+        if dataset is not None and not (isinstance(dataset, torch.utils.data.Dataset) or isinstance(dataset, Dataset)):
+            raise ValueError("dataset must be a torch.utils.data.Dataset or datasets.Dataset")
+        elif dataset is None:
+            warnings.warn(
+                "No dataset is provided. Make sure to set config.batch_size to the correct value before training.",
+                UserWarning,
+            )
+        self.dataset = dataset
+        self._signature_columns = None
+        if self.dataset is not None:
+            self.dataloader = self.prepare_dataloader(self.dataset, data_collator)
+        elif self.dataset is None and self.accelerator.num_processes > 1:
+            warnings.warn(
+                "No dataset is provided. In a multi-GPU setting, this will lead to an error. You should"
+                " prepare your dataloader yourself with `dataloader = ppo_trainer.accelerator.prepare(dataloader)`"
+                " and using `torch.utils.data.DataLoader`, or pass a dataset to the `PPOTrainer`. Please "
+                " refer to the documentation for more details.",
+                UserWarning,
+            )
+            self.dataloader = None
+        else:
+            self.dataloader = None
+
+        # Step 3: Initialize optimizer and data collator
+        if training_data_collator is None:
+            self.data_collator = DataCollatorForLanguageModeling(self.tokenizer, mlm=False)
+        else:
+            self.data_collator = training_data_collator
+        if optimizer is None:
+            self.optimizer = Adam(
+                filter(lambda p: p.requires_grad, self.model.parameters()),
+                lr=self.config.learning_rate,
+            )
+        else:
+            self.optimizer = optimizer
+
+        self.lr_scheduler = lr_scheduler
+        if self.lr_scheduler is not None:
+            lr_scheduler_class = (
+                torch.optim.lr_scheduler._LRScheduler
+                if not is_torch_greater_2_0()
+                else torch.optim.lr_scheduler.LRScheduler
+            )
+
+            # if not isinstance(self.lr_scheduler, lr_scheduler_class):
+            #     raise ValueError(
+            #         "lr_scheduler must be a torch.optim.lr_scheduler._LRScheduler or torch.optim.lr_scheduler.LRScheduler (for torch >= 2.0)"
+            #     )
+
+        if self.config.adap_kl_ctrl:
+            self.kl_ctl = AdaptiveKLController(self.config.init_kl_coef, self.config.target, self.config.horizon)
+        else:
+            self.kl_ctl = FixedKLController(self.config.init_kl_coef)
+
+        # Safety checkers for DS integration
+        is_deepspeed_used = self.accelerator.distributed_type == "DEEPSPEED" and hasattr(
+            self.accelerator.state, "deepspeed_plugin"
+        )
+        
+        self.is_deepspeed_used = is_deepspeed_used
+        logger.info('#### is_deepspeed_used ####')
+        logger.info(self.is_deepspeed_used)
+
+        if config.gradient_checkpointing:
+            self.model.gradient_checkpointing_enable()
+
+            if hasattr(self.model, "enable_input_require_grads"):
+                self.model.enable_input_require_grads()
+            else:
+                # For backward compatibility with older versions of transformers
+                def make_inputs_require_grad(module, input, output):
+                    output.requires_grad_(True)
+
+                self.model.pretrained_model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+        if hasattr(self.lr_scheduler, "step"):
+            logger.info('###self.lr_scheduler has step###')
+            (
+                self.model,
+                self.optimizer,
+                self.data_collator,
+                self.dataloader,
+            ) = self.accelerator.prepare(
+                self.model,
+                self.optimizer,
+                self.data_collator,
+                self.dataloader,
+            )
+        else:
+            logger.info('###self.lr_scheduler has no step###')
+            (
+                self.model,
+                self.optimizer,
+                self.data_collator,
+                self.dataloader,
+                # self.lr_scheduler,
+            ) = self.accelerator.prepare(
+                self.model,
+                self.optimizer,
+                self.data_collator,
+                self.dataloader,
+                # self.lr_scheduler,
+            )
+        
+        logger.info('#####self.optimizer-defaults#####')
+        logger.info(self.optimizer.optimizer.optimizer.defaults)
+        logger.info('#####self.optimizer#####')
+        logger.info(self.optimizer)
+        logger.info('#####self.optimizer.optimizer#####')
+        logger.info(self.optimizer.optimizer)
+        
+        if is_deepspeed_used and isinstance(self.optimizer, DeepSpeedOptimizerWrapper):
+            self.lr_scheduler = get_scheduler(
+                        training_args.lr_scheduler_type,
+                        optimizer=self.optimizer.optimizer.optimizer,
+                        num_warmup_steps=self.training_args.get_warmup_steps(self.num_training_steps),
+                        num_training_steps=self.num_training_steps
+            )
+            logger.info('#####self.lr_scheduler.lr_lambdas#####')
+            logger.info(self.lr_scheduler.lr_lambdas)
+                        
+        if is_deepspeed_used:
+            # Quantized models are already set on the correct device
+            if not self.is_peft_model and not (
+                getattr(self.ref_model.pretrained_model, "is_loaded_in_8bit", False)
+                or getattr(self.ref_model.pretrained_model, "is_loaded_in_4bit", False)
+            ):
+                self.ref_model = self.my_prepare_deepspeed(self.ref_model)
+        else:
+            self.ref_model = self.accelerator.prepare(self.ref_model)
+        
+        logger.info('#####self.lr_scheduler#####')
+        logger.info(self.lr_scheduler)
+
+        # In a distributed setup, only logging needs to be performed on the main process
+        # check: https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html
+        # or: https://discuss.pytorch.org/t/use-distributed-data-parallel-correctly/82500/11
+        self.is_distributed = self.accelerator.num_processes > 1
+
+        # init the current step
+        self.current_step = 0
+
+        # init variables for pushing model to hub
+        if config.push_to_hub_if_best_kwargs:
+            if "repo_id" not in config.push_to_hub_if_best_kwargs:
+                raise ValueError("You have to specify repo_id in order to push the model to the hub!")
+            self.push_to_hub_kwargs = config.push_to_hub_if_best_kwargs
+            self.compare_step = 0
+            self.highest_reward = torch.tensor(-float("inf"))
+
+        # post process for PP
+        if not getattr(self.model, "is_sequential_parallel", False):
+            self.current_device = self.accelerator.device
+        else:
+            if is_torch_xpu_available():
+                self.current_device = torch.device("xpu:0")
+            elif is_torch_npu_available():
+                self.current_device = torch.device("npu:0")
+            else:
+                self.current_device = torch.device("cuda:0")
+
+        PPODecorators.optimize_device_cache = self.config.optimize_device_cache
+
+        self.running = RunningMoments(self.accelerator)
+
+    def _filter_kwargs(self, kwargs, target_func):
+        """
+        filter the keyword arguments that are supported by the target function.
+
+        Args:
+            kwargs (dict):
+                Keyword arguments
+            target_func (function):
+                Target function
+        """
+        return {k: v for k, v in kwargs.items() if k in inspect.signature(target_func).parameters.keys()}
+
+    def prepare_dataloader(self, dataset: Union[torch.utils.data.Dataset, Dataset], data_collator=None):
+        """
+        Prepare the dataloader for training.
+
+        Args:
+            dataset (Union[`torch.utils.data.Dataset`, `datasets.Dataset`]):
+                PyTorch dataset or Hugging Face dataset. If a Hugging Face dataset is passed, the dataset
+                will be preprocessed by removing the columns that are not used by the model.
+            data_collator (Optional[function]):
+                Data collator function.
+
+        Returns:
+            `torch.utils.data.DataLoader`: PyTorch dataloader
+        """
+        if isinstance(dataset, Dataset):
+            dataset = self._remove_unused_columns(dataset)
+        dataloader = torch.utils.data.DataLoader(
+            dataset,
+            batch_size=self.config.batch_size,
+            collate_fn=data_collator,
+            shuffle=True,
+            drop_last=True,
+        )
+        return dataloader
+
+    # Adapted from transformers.Trainer._set_signature_columns_if_needed
+    def _set_signature_columns_if_needed(self):
+        if self._signature_columns is None:
+            # Inspect model forward signature to keep only the arguments it accepts.
+            signature = inspect.signature(self.model.forward)
+            self._signature_columns = list(signature.parameters.keys())
+            # label => sentiment | we need query and response for logging purpose
+            self._signature_columns += ["label", "query", "response"]
+
+    # Adapted from transformers.Trainer._remove_unused_columns
+    def _remove_unused_columns(self, dataset: "Dataset"):
+        if not self.config.remove_unused_columns:
+            return dataset
+        self._set_signature_columns_if_needed()
+        signature_columns = self._signature_columns
+
+        ignored_columns = list(set(dataset.column_names) - set(signature_columns))
+
+        columns = [k for k in signature_columns if k in dataset.column_names]
+
+        if version.parse(datasets.__version__) < version.parse("1.4.0"):
+            dataset.set_format(
+                type=dataset.format["type"],
+                columns=columns,
+                format_kwargs=dataset.format["format_kwargs"],
+            )
+            return dataset
+        else:
+            return dataset.remove_columns(ignored_columns)
+
+    def generate(
+        self,
+        query_tensor: Union[torch.Tensor, List[torch.Tensor]],
+        length_sampler: Optional[Callable] = None,
+        batch_size: int = 4,
+        return_prompt: bool = True,
+        generate_ref_response: bool = False,
+        **generation_kwargs,
+    ):
+        """
+        Generate response with the model given the query tensor.
+        call the `generate` method of the model.
+
+        Args:
+            query_tensor (`torch.LongTensor`):
+                A tensor of shape (`seq_len`) containing query tokens or a list of tensors of shape (`seq_len`).
+            length_sampler (`Callable`, *optional*):
+                Callable that returns the number of newly generated tokens.
+            batch_size (`int`, *optional):
+                Batch size used for generation, defaults to `4`.
+            return_prompt (`bool`, *optional*):
+                If set to `False` the prompt is not returned but only the newly generated tokens, defaults to `True`.
+            generate_ref_response (`bool`, *optional*):
+                If set to `True` the reference response is also generated, defaults to `False`.
+            generation_kwargs (dict[str, Any]):
+                Keyword arguments for generation.
+
+        Returns:
+            `torch.LongTensor`: A tensor of shape (`batch_size`, `gen_len`) containing response tokens.
+        """
+        if generate_ref_response:
+            ref_model = self.model if self.is_peft_model else self.ref_model
+        if isinstance(query_tensor, List):
+            response = self._generate_batched(
+                self.model,
+                query_tensor,
+                length_sampler=length_sampler,
+                batch_size=batch_size,
+                return_prompt=return_prompt,
+                **generation_kwargs,
+            )
+            if generate_ref_response:
+                ref_response = self._generate_batched(
+                    ref_model,
+                    query_tensor,
+                    length_sampler=length_sampler,
+                    batch_size=batch_size,
+                    return_prompt=return_prompt,
+                    **generation_kwargs,
+                )
+
+        else:
+            if len(query_tensor.shape) == 2:
+                raise ValueError(
+                    "query_tensor must be a tensor of shape (`seq_len`) or a list of tensors of shape (`seq_len`)"
+                )
+
+            if length_sampler is not None:
+                generation_kwargs["max_new_tokens"] = length_sampler()
+
+            with unwrap_model_for_generation(self.model, self.accelerator) as unwrapped_model:
+                response = unwrapped_model.generate(input_ids=query_tensor.unsqueeze(dim=0), **generation_kwargs)
+
+            if generate_ref_response:
+                with unwrap_model_for_generation(
+                    ref_model, self.accelerator, is_peft_model=self.is_peft_model
+                ) as unwrapped_model:
+                    ref_response = unwrapped_model.generate(
+                        input_ids=query_tensor.unsqueeze(dim=0), **generation_kwargs
+                    )
+
+            if not return_prompt and not self.is_encoder_decoder:
+                response = response[:, query_tensor.shape[0] :]
+                if generate_ref_response:
+                    ref_response = ref_response[:, query_tensor.shape[0] :]
+
+        if generate_ref_response:
+            return response, ref_response
+        return response
+
+    def _generate_batched(
+        self,
+        model: PreTrainedModelWrapper,
+        query_tensors: List[torch.Tensor],
+        length_sampler: Optional[Callable] = None,
+        batch_size: int = 4,
+        return_prompt: bool = True,
+        pad_to_multiple_of: Optional[int] = None,
+        remove_padding: bool = True,
+        **generation_kwargs,
+    ):
+        outputs = []
+
+        padding_side_default = self.tokenizer.padding_side
+        if not self.is_encoder_decoder:
+            self.tokenizer.padding_side = "left"
+
+        # in case we have fewer examples than bs
+        batch_size = min(len(query_tensors), batch_size)
+
+        for i in range(0, len(query_tensors), batch_size):
+            if length_sampler is not None:
+                generation_kwargs["max_new_tokens"] = length_sampler()
+
+            # prevent overflow if query tensors are not even multiple of bs
+            end_index = min(len(query_tensors), i + batch_size)
+
+            batch = query_tensors[i:end_index]
+            batch_mask = [torch.ones_like(element) for element in batch]
+            inputs = {"input_ids": batch, "attention_mask": batch_mask}
+
+            padded_inputs = self.tokenizer.pad(
+                inputs,
+                padding=True,
+                max_length=None,
+                pad_to_multiple_of=pad_to_multiple_of,
+                return_tensors="pt",
+            ).to(self.current_device)
+
+            with unwrap_model_for_generation(model, self.accelerator) as unwrapped_model:
+                generations = unwrapped_model.generate(**padded_inputs, **generation_kwargs)
+
+            for generation, mask in zip(generations, padded_inputs["attention_mask"]):
+                if not self.is_encoder_decoder:
+                    output = generation[(1 - mask).sum() :]  # remove padding
+                else:
+                    output = generation
+
+                if not return_prompt and not self.is_encoder_decoder:
+                    output = output[(mask).sum() :]  # remove prompt
+
+                if remove_padding and self.tokenizer.eos_token_id in output:
+                    pad_mask = output == self.tokenizer.eos_token_id
+                    pad_start = torch.nonzero(pad_mask, as_tuple=False)[0, 0].item()
+                    output = output[: pad_start + 1]  # keep the eos token at the end
+
+                outputs.append(output)
+
+        self.tokenizer.padding_side = padding_side_default
+        return outputs
+
+    def _step_safety_checker(
+        self,
+        batch_size: int,
+        queries: List[torch.LongTensor],
+        responses: List[torch.LongTensor],
+        scores: List[torch.FloatTensor],
+        masks: Optional[List[torch.LongTensor]] = None,
+    ):
+        """
+        Check if the input data is valid for training.
+
+        Args:
+            batch_size (int):
+                Batch size from the config file.
+            queries (List[`torch.LongTensor`]):
+                List of tensors containing the encoded queries of shape (`query_length`)
+            responses (List[`torch.LongTensor`]):
+                List of tensors containing the encoded responses of shape (`response_length`)
+            scores (List[`torch.FloatTensor`]):
+                List of tensors containing the scores.
+            masks (List[`torch.LongTensor`], *optional*):
+                list of optional tensors containing the masks of shape (`response_length`)
+
+        Returns:
+            `tuple`: The input processed data.
+        """
+        for name, tensor_list in zip(["queries", "responses", "scores"], [queries, responses, scores]):
+            if not isinstance(tensor_list, list):
+                raise ValueError(f"{name} must be a list of tensors - got {type(tensor_list)}")
+            if not isinstance(tensor_list[0], torch.Tensor):
+                raise ValueError(f"Elements in {name} must be tensors - got {type(tensor_list[0])}")
+            if batch_size is not None and len(tensor_list) != batch_size:
+                raise ValueError(
+                    f"Batch size ({batch_size}) does not match number of examples - but got {len(tensor_list)} for: {name}"
+                )
+
+        # add queries, scores and responses on the correct device
+        queries = [tensor.to(self.current_device) for tensor in queries]
+        responses = [tensor.to(self.current_device) for tensor in responses]
+        scores = [tensor.to(self.current_device) for tensor in scores]
+        masks = [tensor.to(self.current_device) for tensor in masks] if masks is not None else None
+
+        # squeeze scores if needed
+        for i, score in enumerate(scores):
+            if score.dim() > 1:
+                raise ValueError(f"Scores must be 1-dimensional - got {score.dim()} for {score}")
+            elif score.dim() == 1:
+                scores[i] = score.squeeze()
+
+        return queries, responses, scores, masks
+
+    @PPODecorators.empty_device_cache()
+    def step(
+        self,
+        queries: List[torch.LongTensor],
+        responses: List[torch.LongTensor],
+        scores: List[torch.FloatTensor],
+        response_masks: Optional[List[torch.LongTensor]] = None,
+    ):
+        """
+        Run a PPO optimisation step given a list of queries, model responses, and rewards.
+
+        Args:
+            queries (List[`torch.LongTensor`]):
+                List of tensors containing the encoded queries of shape (`query_length`)
+            responses (List[`torch.LongTensor`]):
+                List of tensors containing the encoded responses of shape (`response_length`)
+            scores (List[`torch.FloatTensor`]):
+                List of tensors containing the scores.
+            response_masks (List[`torch.FloatTensor`], *optional*)):
+                List of tensors containing masks of the response tokens.
+
+        Returns:
+            `dict[str, Any]`: A summary of the training statistics
+        """
+        bs = self.config.batch_size
+
+        queries, responses, scores, response_masks = self._step_safety_checker(
+            bs, queries, responses, scores, response_masks
+        )
+        scores = torch.tensor(scores, device=self.current_device)
+        if self.config.use_score_scaling:
+            # Score scaling
+            scores_mean, scores_std = self.running.update(scores)
+            tensor_to_kwargs = dict(dtype=scores.dtype, device=scores.device)
+            score_scaling_factor = self.running.std.to(**tensor_to_kwargs) + torch.finfo(scores.dtype).eps
+            if self.config.use_score_norm:
+                scores = (scores - self.running.mean.to(**tensor_to_kwargs)) / score_scaling_factor
+            else:
+                scores /= score_scaling_factor
+
+        if self.config.score_clip is not None:
+            # Score clipping
+            scores_dtype = scores.dtype
+            scores = torch.clip(scores.float(), -self.config.score_clip, self.config.score_clip).to(dtype=scores_dtype)
+
+        # if we want to push best model to the hub
+        if hasattr(self, "highest_reward"):
+            if self.compare_step % self.config.compare_steps == 0:
+                curr_mean_reward = scores.mean()
+                # if the best reward ever seen
+                if curr_mean_reward > self.highest_reward:
+                    self.highest_reward = curr_mean_reward
+                    # push model to hub
+                    self.push_to_hub(**self.push_to_hub_kwargs)
+            self.compare_step += 1
+
+        timing = dict()
+        t0 = time.time()
+
+        t = time.time()
+
+        model_inputs = self.prepare_model_inputs(queries, responses)
+
+        if self.is_distributed:
+            pad_first = self.tokenizer.padding_side == "left"
+
+            model_inputs["input_ids"] = self.accelerator.pad_across_processes(
+                model_inputs["input_ids"],
+                dim=1,
+                pad_index=self.tokenizer.pad_token_id,
+                pad_first=pad_first,
+            )
+            model_inputs["attention_mask"] = self.accelerator.pad_across_processes(
+                model_inputs["attention_mask"], dim=1, pad_index=0, pad_first=pad_first
+            )
+            if self.is_encoder_decoder:
+                model_inputs["decoder_input_ids"] = self.accelerator.pad_across_processes(
+                    model_inputs["decoder_input_ids"],
+                    dim=1,
+                    pad_index=self.tokenizer.pad_token_id,
+                    pad_first=pad_first,
+                )
+                model_inputs["decoder_attention_mask"] = self.accelerator.pad_across_processes(
+                    model_inputs["decoder_attention_mask"],
+                    dim=1,
+                    pad_index=0,
+                    pad_first=pad_first,
+                )
+
+        model_inputs_names = list(model_inputs.keys())
+
+        full_kl_penalty = self.config.kl_penalty == "full"
+
+        with torch.no_grad():
+            all_logprobs, logits_or_none, values, masks = self.batched_forward_pass(
+                self.model,
+                queries,
+                responses,
+                model_inputs,
+                response_masks=response_masks,
+                return_logits=full_kl_penalty,
+            )
+            with self.optional_peft_ctx():
+                ref_logprobs, ref_logits_or_none, _, _ = self.batched_forward_pass(
+                    self.model if self.is_peft_model else self.ref_model,
+                    queries,
+                    responses,
+                    model_inputs,
+                    return_logits=full_kl_penalty,
+                )
+
+        timing["time/ppo/forward_pass"] = time.time() - t
+
+        with torch.no_grad():
+            t = time.time()
+            if full_kl_penalty:
+                active_full_logprobs = logprobs_from_logits(logits_or_none, None, gather=False)
+                ref_full_logprobs = logprobs_from_logits(ref_logits_or_none, None, gather=False)
+
+                rewards, non_score_reward, kls = self.compute_rewards(
+                    scores, active_full_logprobs, ref_full_logprobs, masks
+                )
+            else:
+                rewards, non_score_reward, kls = self.compute_rewards(scores, all_logprobs, ref_logprobs, masks)
+            timing["time/ppo/compute_rewards"] = time.time() - t
+
+            t = time.time()
+            values, advantages, returns = self.compute_advantages(values, rewards, masks)
+            timing["time/ppo/compute_advantages"] = time.time() - t
+
+        # upcast to float32 to avoid dataset issues
+        batch_dict = {
+            "queries": queries,
+            "responses": responses,
+            "logprobs": all_logprobs.to(torch.float32),
+            "values": values.to(torch.float32),
+            "masks": masks,
+            "advantages": advantages,
+            "returns": returns,
+        }
+        batch_dict.update(model_inputs)
+
+        t = time.time()
+        all_stats = []
+        early_stop = False
+        for ppo_epoch in range(self.config.ppo_epochs):
+            if early_stop:
+                break
+            b_inds = np.random.permutation(bs)
+            for backward_batch_start in range(0, bs, self.config.backward_batch_size):
+                backward_batch_end = backward_batch_start + self.config.backward_batch_size
+                backward_batch_inds = b_inds[backward_batch_start:backward_batch_end]
+
+                for mini_batch_start in range(0, self.config.backward_batch_size, self.config.mini_batch_size):
+                    mini_batch_end = mini_batch_start + self.config.mini_batch_size
+                    mini_batch_inds = backward_batch_inds[mini_batch_start:mini_batch_end]
+                    mini_batch_dict = {
+                        "logprobs": batch_dict["logprobs"][mini_batch_inds],
+                        "values": batch_dict["values"][mini_batch_inds],
+                        "masks": batch_dict["masks"][mini_batch_inds],
+                        # hacks: the queries and responses are ragged.
+                        "queries": [batch_dict["queries"][i] for i in mini_batch_inds],
+                        "responses": [batch_dict["responses"][i] for i in mini_batch_inds],
+                        "advantages": batch_dict["advantages"][mini_batch_inds],
+                        "returns": batch_dict["returns"][mini_batch_inds],
+                    }
+                    for k in model_inputs_names:
+                        mini_batch_dict[k] = batch_dict[k][mini_batch_inds]
+                    with self.accelerator.accumulate(self.model):
+                        model_inputs = {k: mini_batch_dict[k] for k in model_inputs_names}
+
+                        logprobs, logits, vpreds, _ = self.batched_forward_pass(
+                            self.model,
+                            mini_batch_dict["queries"],
+                            mini_batch_dict["responses"],
+                            model_inputs,
+                            return_logits=True,
+                        )
+
+                        tmp = {
+                            'learing_rate': self._get_learning_rate(),
+                            'ppo_epoch': ppo_epoch,
+                            'backward_batch_start': backward_batch_start,
+                            'mini_batch_start': mini_batch_start,
+                            'key': "before optimizer-step",
+                        }
+
+                        logger.info("####before step####")
+                        # logger.info(self.lr_scheduler.last_batch_iteration)
+                        logger.info(self.lr_scheduler.lr_lambdas)
+                        logger.info(json.dumps(tmp))
+
+                        train_stats = self.train_minibatch(
+                            mini_batch_dict["logprobs"],
+                            mini_batch_dict["values"],
+                            logprobs,
+                            logits,
+                            vpreds,
+                            mini_batch_dict["masks"],
+                            mini_batch_dict["advantages"],
+                            mini_batch_dict["returns"],
+                        )
+                        all_stats.append(train_stats)
+
+                        tmp = {
+                            'learing_rate': self._get_learning_rate(),
+                            'ppo_epoch': ppo_epoch,
+                            'backward_batch_start': backward_batch_start,
+                            'mini_batch_start': mini_batch_start,
+                            'key': "after optimizer-step",
+                        }
+                        logger.info("####after step####")
+                        # logger.info(self.lr_scheduler.last_batch_iteration)
+                        logger.info(self.lr_scheduler.lr_lambdas)
+                        logger.info(json.dumps(tmp))
+
+            # typically, early stopping is done at the epoch level
+            if self.config.early_stopping:
+                policykl = train_stats["policy/policykl"]
+                early_stop = self._early_stop(policykl)
+                if early_stop:
+                    break
+                    
+        logger.info('===finished ppo-step===')
+
+        timing["time/ppo/optimize_step"] = time.time() - t
+
+        t = time.time()
+        train_stats = stack_dicts(all_stats)
+
+        # reshape advantages/ratios such that they are not averaged.
+        train_stats["policy/advantages"] = torch.flatten(train_stats["policy/advantages"]).unsqueeze(0)
+        train_stats["policy/advantages"] = torch.nan_to_num(train_stats["policy/advantages"], WANDB_PADDING)
+        train_stats["policy/ratio"] = torch.flatten(train_stats["policy/ratio"]).unsqueeze(0)
+
+        stats = self.record_step_stats(
+            scores=scores,
+            logprobs=all_logprobs,
+            ref_logprobs=ref_logprobs,
+            non_score_reward=non_score_reward,
+            train_stats=train_stats,
+            kl_coef=self.kl_ctl.value,
+            masks=masks,
+            queries=queries,
+            responses=responses,
+            kls=kls,
+        )
+        # Gather/Reduce stats from all processes
+        if self.is_distributed:
+            stats = self.gather_stats(stats)
+        stats = stats_to_np(stats)
+        timing["time/ppo/calc_stats"] = time.time() - t
+        if self.is_deepspeed_used:
+            stats["ppo/learning_rate"] = self._get_learning_rate()
+            stats["ppo/learning_rate_optimizer"] = self.optimizer.param_groups[0]["lr"]
+        else:
+            stats["ppo/learning_rate"] = self.optimizer.param_groups[0]["lr"]
+
+        # Update the KL control - multiply the batch_size by the number of processes
+        self.kl_ctl.update(
+            stats["objective/kl"],
+            self.config.batch_size * self.accelerator.num_processes,
+        )
+
+        # Log the total ppo time
+        timing["time/ppo/total"] = time.time() - t0
+        stats.update(timing)
+
+        # post-process stats for tensorboard and other loggers
+        if self.config.log_with != "wandb":
+            stats = convert_to_scalar(stats)
+
+        if self.lr_scheduler is not None:
+            logger.info("###before-lr_scheduler_step###")
+            logger.info(self._get_learning_rate())
+            self.lr_scheduler.step()
+            logger.info("###after-lr_scheduler_step###")
+            logger.info(self._get_learning_rate())
+
+        return stats
+
+    def _early_stop(self, policykl):
+        r"""
+        Handles the early stopping logic. If the policy KL is greater than the target KL, then the gradient is zeroed and
+        the optimization step is skipped.
+        This also handles the multi-gpu case where the policy KL is averaged across all processes.
+
+        Args:
+            policy_kl (torch.Tensor):
+                the policy KL
+
+        Returns:
+            `bool`: whether to early stop or not
+        """
+        early_stop = False
+        if not self.config.early_stopping:
+            return early_stop
+
+        if not self.is_distributed and policykl > 1.5 * self.config.target_kl:
+            self.optimizer.zero_grad()
+            early_stop = True
+        elif self.is_distributed:
+            import torch.distributed as dist
+
+            # Wait for all processes to finish
+            dist.barrier()
+
+            # all gather the policykl
+            dist.all_reduce(policykl, dist.ReduceOp.SUM)
+            policykl /= self.accelerator.num_processes
+
+            if policykl > 1.5 * self.config.target_kl:
+                self.optimizer.zero_grad()
+                early_stop = True
+        return early_stop
+
+    def gather_stats(self, stats):
+        """
+        Gather stats from all processes. Useful in the context of distributed training.
+
+        Args:
+            stats (dict[str, Any]):
+            a dictionary of stats to be gathered. The stats should contain torch tensors.
+
+        Returns:
+            `dict[str, Any]`: A dictionary of stats with the tensors gathered.
+        """
+        import torch.distributed as dist
+
+        # Wait for all processes to finish
+        dist.barrier()
+
+        for k, v in stats.items():
+            if isinstance(v, torch.Tensor):
+                dist.all_reduce(v.to(self.accelerator.device), dist.ReduceOp.SUM)
+                v /= self.accelerator.num_processes
+            stats[k] = v
+        return stats
+
+    def prepare_model_inputs(self, queries: torch.Tensor, responses: torch.Tensor):
+        if self.is_encoder_decoder:
+            input_data = self.data_collator(
+                [{"input_ids": q, "attention_mask": torch.ones_like(q)} for q in queries]
+            ).to(self.current_device)
+
+            decoder_inputs = self.data_collator(
+                [{"input_ids": r, "attention_mask": torch.ones_like(r)} for r in responses]
+            ).to(self.current_device)
+
+            input_data["decoder_input_ids"] = decoder_inputs["input_ids"]
+            input_data["decoder_attention_mask"] = decoder_inputs["attention_mask"]
+        else:
+            input_ids = [torch.cat([q, r]) for q, r in zip(queries, responses)]
+            input_data = self.data_collator(
+                [{"input_ids": ids, "attention_mask": torch.ones_like(ids)} for ids in input_ids]
+            ).to(self.current_device)
+
+        input_data.pop("labels", None)  # we don't want to compute LM losses
+        return input_data
+
+    @PPODecorators.empty_device_cache()
+    def batched_forward_pass(
+        self,
+        model: PreTrainedModelWrapper,
+        queries: torch.Tensor,
+        responses: torch.Tensor,
+        model_inputs: dict,
+        return_logits: bool = False,
+        response_masks: Optional[torch.Tensor] = None,
+    ):
+        """
+        Calculate model outputs in multiple batches.
+
+        Args:
+            queries (`torch.LongTensor`):
+                List of tensors containing the encoded queries, shape (`batch_size`, `query_length`)
+            responses (`torch.LongTensor`):
+                List of tensors containing the encoded responses, shape (`batch_size`, `response_length`)
+            return_logits (`bool`, *optional*, defaults to `False`):
+                Whether to return all_logits. Set to `False` if logits are not needed to reduce memory consumption.
+
+        Returns:
+            (tuple):
+                - all_logprobs (`torch.FloatTensor`): Log probabilities of the responses,
+                    shape (`batch_size`, `response_length`)
+                - all_ref_logprobs (`torch.FloatTensor`): Log probabilities of the responses,
+                    shape (`batch_size`, `response_length`)
+                - all_values (`torch.FloatTensor`): Values of the responses, shape (`batch_size`, `response_length`)
+        """
+        bs = len(queries)
+        fbs = self.config.mini_batch_size
+        all_logprobs = []
+        all_logits = []
+        all_masks = []
+        all_values = []
+
+        model.eval()
+
+        for i in range(math.ceil(bs / fbs)):
+            input_kwargs = {key: value[i * fbs : (i + 1) * fbs] for key, value in model_inputs.items()}
+            query_batch = queries[i * fbs : (i + 1) * fbs]
+            response_batch = responses[i * fbs : (i + 1) * fbs]
+            if response_masks is not None:
+                response_masks_batch = response_masks[i * fbs : (i + 1) * fbs]
+            logits, _, values = model(**input_kwargs)
+
+            if self.is_encoder_decoder:
+                input_ids = input_kwargs["decoder_input_ids"]
+                attention_mask = input_kwargs["decoder_attention_mask"]
+            else:
+                input_ids = input_kwargs["input_ids"]
+                attention_mask = input_kwargs["attention_mask"]
+
+            logprobs = logprobs_from_logits(logits[:, :-1, :], input_ids[:, 1:])
+            masks = torch.zeros_like(attention_mask)
+            masks[:, :-1] = attention_mask[:, 1:]
+
+            for j in range(len(query_batch)):
+                if self.is_encoder_decoder:
+                    # Decoder sentence starts always in the index 1 after padding in the Enc-Dec Models
+                    start = 1
+                    end = attention_mask[j, :].sum() - 1
+                else:
+                    start = len(query_batch[j]) - 1  # logprobs starts from the second query token
+                    if attention_mask[j, 0] == 0:  # offset left padding
+                        start += attention_mask[j, :].nonzero()[0]
+                    end = start + len(response_batch[j])
+
+                masks[j, :start] = 0
+                masks[j, end:] = 0
+                if response_masks is not None:
+                    masks[j, start:end] = masks[j, start:end] * response_masks_batch[j]
+
+            if return_logits:
+                all_logits.append(logits)
+            else:
+                del logits
+            all_values.append(values)
+            all_logprobs.append(logprobs)
+            all_masks.append(masks)
+
+        return (
+            torch.cat(all_logprobs),
+            torch.cat(all_logits)[:, :-1] if return_logits else None,
+            torch.cat(all_values)[:, :-1],
+            torch.cat(all_masks)[:, :-1],
+        )
+
+    @PPODecorators.empty_device_cache()
+    def train_minibatch(
+        self,
+        old_logprobs: torch.FloatTensor,
+        values: torch.FloatTensor,
+        logprobs: torch.FloatTensor,
+        logits: torch.FloatTensor,
+        vpreds: torch.FloatTensor,
+        mask: torch.LongTensor,
+        advantages: torch.FloatTensor,
+        returns: torch.FloatTensor,
+    ):
+        """
+        Train one PPO minibatch
+
+        Args:
+            logprobs (`torch.FloatTensor`):
+                Log probabilities of the model, shape [mini_batch_size, response_length]
+            values (`torch.FloatTensor`):
+                Values of the value head, shape [mini_batch_size, response_length]
+            query (`torch.LongTensor`):
+                Encoded queries, shape [mini_batch_size, query_length]
+            response (`torch.LongTensor`):
+                Encoded responses, shape [mini_batch_size, response_length]
+            model_input (`torch.LongTensor`):
+                Concatenated queries and responses, shape [mini_batch_size, query_length+response_length]
+
+        Returns:
+            train_stats (dict[str, `torch.Tensor`]):
+                Dictionary of training statistics
+        """
+        self.model.train()
+        loss_p, loss_v, train_stats = self.loss(
+            old_logprobs, values, logits, vpreds, logprobs, mask, advantages, returns
+        )
+        loss = loss_p + loss_v
+        self.accelerator.backward(loss)
+        if self.config.max_grad_norm is not None:
+            if self.accelerator.sync_gradients:
+                self.accelerator.clip_grad_norm_(self.model_params, self.config.max_grad_norm)
+        self.optimizer.step()
+        # we call optimizer.zero_grad() every time and let `accelerator` handle accumulation
+        # see https://huggingface.co/docs/accelerate/usage_guides/gradient_accumulation#the-finished-code
+        self.optimizer.zero_grad()
+        return train_stats
+
+    def compute_rewards(
+        self,
+        scores: torch.FloatTensor,
+        logprobs: torch.FloatTensor,
+        ref_logprobs: torch.FloatTensor,
+        masks: torch.LongTensor,
+    ):
+        """
+        Compute per token rewards from scores and KL-penalty.
+
+        Args:
+            scores (`torch.FloatTensor`):
+                Scores from the reward model, shape (`batch_size`)
+            logprobs (`torch.FloatTensor`):
+                Log probabilities of the model, shape (`batch_size`, `response_length`)
+            ref_logprobs (`torch.FloatTensor`):
+                Log probabilities of the reference model, shape (`batch_size`, `response_length`)
+
+        Returns:
+            `torch.FloatTensor`: Per token rewards, shape (`batch_size`, `response_length`)
+            `torch.FloatTensor`: Non score rewards, shape (`batch_size`, `response_length`)
+            `torch.FloatTensor`: KL penalty, shape (`batch_size`, `response_length`)
+        """
+        rewards, non_score_rewards, kls = [], [], []
+        for score, logprob, ref_logprob, mask in zip(scores, logprobs, ref_logprobs, masks):
+            # compute KL penalty (from difference in logprobs)
+            kl = self._kl_penalty(logprob, ref_logprob)
+            kls.append(kl)
+            non_score_reward = -self.kl_ctl.value * kl
+            non_score_rewards.append(non_score_reward)
+            reward = non_score_reward.clone()
+            last_non_masked_index = mask.nonzero()[-1]
+
+            # reward is preference model score + KL penalty
+            reward[last_non_masked_index] += score
+            rewards.append(reward)
+        return torch.stack(rewards), torch.stack(non_score_rewards), torch.stack(kls)
+
+    def _kl_penalty(self, logprob: torch.FloatTensor, ref_logprob: torch.FloatTensor) -> torch.FloatTensor:
+        if self.config.kl_penalty == "kl":
+            return logprob - ref_logprob
+
+        if self.config.kl_penalty == "abs":
+            return (logprob - ref_logprob).abs()
+
+        if self.config.kl_penalty == "mse":
+            return 0.5 * (logprob - ref_logprob).square()
+
+        if self.config.kl_penalty == "full":
+            # Flip is required due to this issue? :https://github.com/pytorch/pytorch/issues/57459
+            return F.kl_div(ref_logprob, logprob, log_target=True, reduction="none").sum(-1)
+        if self.config.kl_penalty == "control_variate":
+            log_ratio = ref_logprob - logprob
+            control_variate = torch.exp(log_ratio) - log_ratio - 1
+            return control_variate
+        if self.config.kl_penalty == "seq_control_variate":
+            log_ratio = ref_logprob - logprob
+            prob_ratio = torch.exp(log_ratio.sum(dim=-1, keepdim=True))
+            seq_control_variate = prob_ratio - log_ratio - 1
+            return seq_control_variate
+
+        raise NotImplementedError
+
+    def compute_advantages(
+        self,
+        values: torch.FloatTensor,
+        rewards: torch.FloatTensor,
+        mask: torch.FloatTensor,
+    ):
+        lastgaelam = 0
+        advantages_reversed = []
+        gen_len = rewards.shape[-1]
+
+        values = values * mask
+        rewards = rewards * mask
+
+        if self.config.whiten_rewards:
+            rewards = masked_whiten(rewards, mask, shift_mean=False)
+
+        for t in reversed(range(gen_len)):
+            nextvalues = values[:, t + 1] if t < gen_len - 1 else 0.0
+            delta = rewards[:, t] + self.config.gamma * nextvalues - values[:, t]
+            lastgaelam = delta + self.config.gamma * self.config.lam * lastgaelam
+            advantages_reversed.append(lastgaelam)
+        advantages = torch.stack(advantages_reversed[::-1]).transpose(0, 1)
+
+        returns = advantages + values
+        if self.config.whiten_advantages:
+            advantages = masked_whiten(advantages, mask)
+        advantages = advantages.detach()
+        return values, advantages, returns
+
+    def loss(
+        self,
+        old_logprobs: torch.FloatTensor,
+        values: torch.FloatTensor,
+        logits: torch.FloatTensor,
+        vpreds: torch.FloatTensor,
+        logprobs: torch.FloatTensor,
+        mask: torch.LongTensor,
+        advantages: torch.FloatTensor,
+        returns: torch.FloatTensor,
+    ):
+        """
+        Calculate policy and value losses.
+
+        Args:
+            old_logprobs (`torch.FloatTensor`):
+                Log probabilities of the model, shape (`batch_size`, `response_length`)
+            values (`torch.FloatTensor`):
+                Values of the value head, shape (`batch_size`, `response_length`)
+            rewards (`torch.FloatTensor`):
+                Rewards from the reward model, shape (`batch_size`, `response_length`)
+            logits (`torch.FloatTensor`):
+                Logits of the model, shape (`batch_size`, `response_length`, `vocab_size`)
+            v_pred (`torch.FloatTensor`):
+                Values of the value head, shape (`batch_size`, `response_length`)
+            logprobs (`torch.FloatTensor`):
+                Log probabilities of the model, shape (`batch_size`, `response_length`)
+        """
+
+        vpredclipped = clip_by_value(
+            vpreds,
+            values - self.config.cliprange_value,
+            values + self.config.cliprange_value,
+        )
+
+        vf_losses1 = (vpreds - returns) ** 2
+        vf_losses2 = (vpredclipped - returns) ** 2
+        vf_loss = 0.5 * masked_mean(torch.max(vf_losses1, vf_losses2), mask)
+        vf_clipfrac = masked_mean(torch.gt(vf_losses2, vf_losses1).float(), mask)
+
+        ratio = torch.exp(logprobs - old_logprobs)
+
+        pg_losses = -advantages * ratio
+        pg_losses2 = -advantages * torch.clamp(ratio, 1.0 - self.config.cliprange, 1.0 + self.config.cliprange)
+
+        pg_loss = masked_mean(torch.max(pg_losses, pg_losses2), mask)
+        pg_clipfrac = masked_mean(torch.gt(pg_losses2, pg_losses).float(), mask)
+
+        loss = pg_loss + self.config.vf_coef * vf_loss
+
+        avg_ratio = masked_mean(ratio, mask).item()
+        if avg_ratio > self.config.ratio_threshold:
+            warnings.warn(
+                f"The average ratio of batch ({avg_ratio:.2f}) exceeds threshold {self.config.ratio_threshold:.2f}. Skipping batch."
+            )
+            pg_loss = pg_loss * 0.0
+            vf_loss = vf_loss * 0.0
+            loss = loss * 0.0
+
+        entropy = masked_mean(entropy_from_logits(logits), mask)
+
+        approxkl = 0.5 * masked_mean((logprobs - old_logprobs) ** 2, mask)
+        policykl = masked_mean(old_logprobs - logprobs, mask)
+
+        return_mean, return_var = masked_mean(returns, mask), masked_var(returns, mask)
+        value_mean, value_var = masked_mean(values, mask), masked_var(values, mask)
+
+        stats = dict(
+            loss=dict(policy=pg_loss.detach(), value=vf_loss.detach(), total=loss.detach()),
+            policy=dict(
+                entropy=entropy.detach(),
+                approxkl=approxkl.detach(),
+                policykl=policykl.detach(),
+                clipfrac=pg_clipfrac.detach(),
+                advantages=advantages.detach(),
+                advantages_mean=masked_mean(advantages, mask).detach(),
+                ratio=ratio.detach(),
+            ),
+            returns=dict(mean=return_mean.detach(), var=return_var.detach()),
+            val=dict(
+                vpred=masked_mean(vpreds, mask).detach(),
+                error=masked_mean((vpreds - returns) ** 2, mask).detach(),
+                clipfrac=vf_clipfrac.detach(),
+                mean=value_mean.detach(),
+                var=value_var.detach(),
+            ),
+        )
+        return pg_loss, self.config.vf_coef * vf_loss, flatten_dict(stats)
+
+    def record_step_stats(self, kl_coef: float, **data):
+        """
+        Record training step statistics.
+
+
+        Args:
+            kl_coef (`float`):
+                KL coefficient
+            data (`dict`):
+                Dictionary of training step data
+
+        Returns:
+            stats (`dict`):
+                Dictionary of training step statistics
+        """
+        mask = data.pop("masks")
+
+        kls = data.pop("kls")
+        kl_list = ((kls) * mask).sum(axis=-1)
+        mean_kl = kl_list.mean()
+        mean_entropy = (-data["logprobs"] * mask).sum(axis=-1).mean()
+
+        mean_non_score_reward = masked_mean(
+            data["non_score_reward"], mask
+        )  # non_score_reward is size `batch_size`, `response_length`
+        mean_scores = data["scores"].mean()  # scores is size `batch_size`
+        std_scores = data["scores"].std()
+
+        if mean_kl.item() < -1.0:
+            # warn users
+            warnings.warn(
+                f"KL divergence is starting to become negative: {mean_kl.item():.2f} - this might be a precursor for failed training."
+                " sometimes this happens because the generation kwargs are not correctly set. Please make sure"
+                " that the generation kwargs are set correctly, or review your training hyperparameters."
+            )
+
+        stats = {
+            "objective/kl": mean_kl,
+            "objective/kl_dist": kl_list,
+            "objective/logprobs": data["logprobs"],
+            "objective/ref_logprobs": data["ref_logprobs"],
+            "objective/kl_coef": kl_coef,
+            "objective/entropy": mean_entropy,
+            "ppo/mean_non_score_reward": mean_non_score_reward,
+            "ppo/mean_scores": mean_scores,
+            "ppo/std_scores": std_scores,
+        }
+
+        # Log text properties
+        query_lens = torch.tensor([len(query) for query in data["queries"]], dtype=torch.float)
+        response_lens = torch.tensor([len(response) for response in data["responses"]], dtype=torch.float)
+
+        stats["tokens/queries_len_mean"] = torch.mean(query_lens).cpu().numpy().item()
+        stats["tokens/queries_len_std"] = torch.std(query_lens).cpu().numpy().item()
+        stats["tokens/queries_dist"] = query_lens.cpu().numpy()
+        stats["tokens/responses_len_mean"] = torch.mean(response_lens).cpu().numpy().item()
+        stats["tokens/responses_len_std"] = torch.std(response_lens).cpu().numpy().item()
+        stats["tokens/responses_dist"] = response_lens.cpu().numpy()
+
+        for k, v in data["train_stats"].items():
+            stats[f"ppo/{k}"] = torch.mean(v, axis=0)
+        stats["ppo/val/var_explained"] = 1 - stats["ppo/val/error"] / stats["ppo/returns/var"]
+        return stats
+
+    def log_stats(
+        self,
+        stats: dict,
+        batch: dict,
+        rewards: List[torch.FloatTensor],
+        columns_to_log: typing.Iterable[str] = ("query", "response"),
+    ):
+        """
+        A function that logs all the training stats. Call it at the end of each epoch.
+
+        Args:
+            stats (dict[str, Any]):
+                A dictionary of training stats.
+            batch (dict[str, Any]):
+                A dictionary of batch data, this contains the queries and responses.
+            rewards (`List[torch.FloatTensor]`):
+                A tensor of rewards.
+        """
+
+        # all gather stats
+        if not isinstance(rewards, torch.Tensor):
+            rewards = torch.tensor(rewards).to(self.current_device)
+        rewards = self.accelerator.gather(rewards).flatten()
+
+        if self.config.log_with == "wandb":
+            import wandb
+
+            if any(column_to_log not in batch.keys() for column_to_log in columns_to_log):
+                raise ValueError(f"Columns to log {columns_to_log} are not present in the batch {batch.keys()}.")
+
+            batch_list = [batch[column_to_log] for column_to_log in columns_to_log]
+            if self.is_distributed:
+                gathered_batch_list = []
+                for b in batch_list:
+                    flattened = gather_object(b)
+                    gathered_batch_list.append(flattened)
+                batch_list = gathered_batch_list
+
+        # Log only if we are in the main process
+        if self.accelerator.is_main_process:
+            logs = {}
+
+            # Log stats
+            if "query" not in batch.keys() and "response" not in batch.keys():
+                # warn the user that the game logs will not be logged
+                warnings.warn(
+                    "The game logs will not be logged because the batch does not contain the keys 'query' and "
+                    "'response'. "
+                )
+            elif self.config.log_with == "wandb":
+                table_rows = [list(r) for r in zip(*batch_list, rewards.cpu().tolist())]
+                logs.update({"game_log": wandb.Table(columns=[*columns_to_log, "reward"], rows=table_rows)})
+
+            logs.update(stats)
+
+            # manually cast in fp32 for bf16 torch tensors
+            for k, v in logs.items():
+                if isinstance(v, torch.Tensor) and v.dtype == torch.bfloat16:
+                    logs[k] = v.float()
+
+            logs["env/reward_mean"] = torch.mean(rewards).cpu().numpy().item()
+            logs["env/reward_std"] = torch.std(rewards).cpu().numpy().item()
+            logs["env/reward_dist"] = rewards.cpu().numpy()
+
+            if self.config.log_with == "tensorboard":
+                # update the current step
+                self.current_step += 1
+
+            self.accelerator.log(
+                logs,
+                step=self.current_step if self.config.log_with == "tensorboard" else None,
+            )
+
+    def create_model_card(self, path: str, model_name: Optional[str] = "TRL Model") -> None:
+        """Creates and saves a model card for a TRL model.
+
+        Args:
+            path (`str`): The path to save the model card to.
+            model_name (`str`, *optional*): The name of the model, defaults to `TRL Model`.
+        """
+        try:
+            user = whoami()["name"]
+        # handle the offline case
+        except Exception:
+            warnings.warn("Cannot retrieve user information assuming you are running in offline mode.")
+            return
+
+        if not os.path.exists(path):
+            os.makedirs(path)
+
+        model_card_content = MODEL_CARD_TEMPLATE.format(model_name=model_name, model_id=f"{user}/{path}")
+        with open(os.path.join(path, "README.md"), "w", encoding="utf-8") as f:
+            f.write(model_card_content)
+
+    def _save_pretrained(self, save_directory: str) -> None:
+        self.accelerator.unwrap_model(self.model).save_pretrained(save_directory)
+        self.tokenizer.save_pretrained(save_directory)
+        self.create_model_card(save_directory)
+
+    def _show_tokens(self, tokens, masks):
+        from rich import print
+        from rich.text import Text
+
+        text = Text()
+
+        for _i, (token, mask) in enumerate(zip(tokens, masks)):
+            if mask == 1:
+                text.append(self.tokenizer.decode(token.item()), style="black on deep_sky_blue1")
+                text.append(" ")
+            else:
+                text.append(self.tokenizer.decode(token.item()), style="black on cyan3")
+                text.append(" ")
+        print(text)
+        
+    def my_prepare_deepspeed(self, model):
+        deepspeed_states = self.accelerator.state.deepspeed_plugin
+        config_kwargs = deepspeed_states.deepspeed_config
+        if config_kwargs["zero_optimization"]["stage"] != 3:
+            stage = 0
+        else:
+            stage = 3
+        ds_config = get_eval_ds_config(deepspeed_states, offload=True, stage=stage)
+        logger.info("####ds_config####")
+        logger.info(ds_config)
+        logger.info("####config_kwargs####")
+        logger.info(config_kwargs)
+        model, *_ = deepspeed.initialize(model=model, config=ds_config)
+        model.eval()
+        return model
+
+    def _prepare_deepspeed(self, model: PreTrainedModelWrapper):
+        # Adapted from accelerate: https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473
+        deepspeed_plugin = self.accelerator.state.deepspeed_plugin
+        config_kwargs = deepspeed_plugin.deepspeed_config
+        if model is not None:
+            if hasattr(model, "config"):
+                hidden_size = (
+                    max(model.config.hidden_sizes)
+                    if getattr(model.config, "hidden_sizes", None)
+                    else getattr(model.config, "hidden_size", None)
+                )
+                if hidden_size is not None and config_kwargs["zero_optimization"]["stage"] == 3:
+                    # Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache @ step 0: expected module 1, but got module 0`
+                    # This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081
+                    config_kwargs.update(
+                        {
+                            "zero_optimization.reduce_bucket_size": hidden_size * hidden_size,
+                            "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size,
+                            "zero_optimization.stage3_prefetch_bucket_size": 0.9 * hidden_size * hidden_size,
+                        }
+                    )
+
+        # If ZeRO-3 is used, we shard both the active and reference model.
+        # Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO disabled (stage 0)
+        if config_kwargs["zero_optimization"]["stage"] != 3:
+            config_kwargs["zero_optimization"]["stage"] = 0
+        model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
+        model.eval()
+        return model

step_dpo_ppo.py

@@ -0,0 +1,344 @@
+# Copyright 2024 HuggingFace Inc. and the LlamaFactory team.
+#
+# This code is inspired by the HuggingFace's TRL library.
+# https://github.com/huggingface/trl/blob/v0.8.0/examples/scripts/ppo.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import random
+random.seed(42)
+
+from typing import TYPE_CHECKING, List, Optional
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Sequence
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Literal, Optional
+import warnings
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+# from llamafactory.extras.ploting import plot_loss
+from llamafactory.train.trainer_utils import create_ref_model, create_reward_model
+from llamafactory.model import load_model, load_tokenizer
+from llamafactory.hparams import DataArguments, FinetuningArguments, GeneratingArguments, ModelArguments
+from ppo_save_utils import FixValueHeadModelCallback, my_fix_valuehead_checkpoint
+
+# from my_ppo_trainer import CustomPPOTrainer
+from my_ppo_trainer_v1 import CustomPPOTrainer
+
+from transformers import Seq2SeqTrainingArguments, TrainerCallback
+from transformers import DataCollatorWithPadding
+import transformers
+
+from torch.utils.data import Dataset
+import torch
+import transformers
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments
+from transformers.integrations import is_deepspeed_zero3_enabled
+from transformers.trainer_utils import get_last_checkpoint
+from transformers.training_args import ParallelMode
+from transformers.utils import is_torch_bf16_gpu_available
+from transformers.utils.versions import require_version
+from transformers.trainer_callback import (
+    DefaultFlowCallback
+)
+import os
+import torch.distributed as dist
+
+import logging
+
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+@dataclass
+class Seq2SeqTrainingArguments(transformers.Seq2SeqTrainingArguments):
+    optim: str = field(default="adamw_torch")
+    model_max_length: int = field(
+        default=512,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    ppo_whiten_advantages: bool = field(
+        default=True,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    init_kl_coef: float = field(
+        default=0.01,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    adap_kl_ctrl: bool = field(
+        default=False,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    kl_penalty: str = field(
+        default="kl",
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    lam: float = field(
+        default=1.0,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+
+
+PROMPT_DICT = {
+    'alpaca_without_response': (
+    "Below is an instruction that describes a task. "
+    "Write a response that appropriately completes the request.\n\n"
+    "### Instruction:\n{prompt}\n\n### Response: Let's think step by step. Step 1:"
+    ),
+    'alpaca_with_response': (
+    "Below is an instruction that describes a task. "
+    "Write a response that appropriately completes the request.\n\n"
+    "### Instruction:\n{prompt}\n\n### Response: {initial_reason_steps}"
+    )
+}
+
+def my_filter(example, tokenizer):
+    query = PROMPT_DICT['alpaca_without_response'].format_map(tmp)
+    if len(tokenizer(query)['input_ids']) > 1024:
+        return False
+    return True
+
+Reverse_Curriculum_RL = os.environ.get('Reverse_Curriculum_RL', '')
+import re
+
+pattern = r"Step \d+:.*?(?=Step \d+:|$)"
+print(Reverse_Curriculum_RL, '==Reverse_Curriculum_RL==')
+
+class PPODataset(Dataset):
+    """Dataset for supervised fine-tuning."""
+
+    def __init__(self, data_path: str, 
+                 tokenizer: transformers.PreTrainedTokenizer, training_args):
+        super(PPODataset, self).__init__()
+        self.training_args = training_args
+        from datasets import load_dataset
+        print('==data_path==', data_path)
+        df = load_dataset('json', 
+                                data_files=data_path)['train']
+        self.df_ = df.filter(lambda example: my_filter, 
+                                num_proc=8)
+        
+        if Reverse_Curriculum_RL == 'apply':
+            data_dict = {}
+            self.df = []
+            for d in self.df_:
+                if d['initial_reason_steps']:
+                    steps = re.findall(pattern, d['initial_reason_steps'], re.DOTALL)
+                else:
+                    steps = []
+                for step_idx, step in enumerate(steps):
+                    tmp = {}
+                    for key in d:
+                        if key in ['initial_reason_steps']:
+                            continue
+                        tmp[key] = d[key]
+                    prefix = ''.join(steps[:step_idx+1])
+                    tmp['initial_reason_steps'] = "Let's think step by step. " + ''.join(prefix)
+                    if tmp['prompt']+tmp['initial_reason_steps'] in data_dict:
+                        continue
+                    self.df.append(tmp)
+                    data_dict[tmp['prompt']+tmp['initial_reason_steps']] = 0
+                tmp = {}
+                for key in d:
+                    if key in ['initial_reason_steps']:
+                        continue
+                    tmp[key] = d[key]
+                if tmp['prompt'] in data_dict:
+                    continue
+                self.df.append(tmp)
+                data_dict[tmp['prompt']] = 0
+        else:
+            self.df = []
+            for d in self.df_:
+                self.df.append(d)
+        
+        self.df += self.df
+        self.idx = list(range(len(self.df)))
+        random.shuffle(self.idx)
+                
+        print(len(self.df), '===dataset===')
+        self.tokenizer = tokenizer
+    
+    def __len__(self):
+        return len(self.df)
+    
+    def __getitem__(self, i):
+        tmp = self.df[self.idx[i]]
+        if Reverse_Curriculum_RL == 'apply':
+            if tmp.get('initial_reason_steps', ''):
+                query = PROMPT_DICT['alpaca_with_response'].format_map(tmp)
+            else:
+                query = PROMPT_DICT['alpaca_without_response'].format_map(tmp)
+        else:
+            query = PROMPT_DICT['alpaca_without_response'].format_map(tmp)
+        
+        tokenized_question = self.tokenizer(
+            query,
+            padding="longest",
+            max_length=self.training_args.model_max_length,
+            truncation=True,
+            add_special_tokens=True
+        )
+        
+        tokenizer_answer = self.tokenizer(
+            tmp['answer'],
+            padding="longest",
+            max_length=self.training_args.model_max_length,
+            truncation=True,
+            add_special_tokens=True
+        )
+        
+        return {
+            'input_ids': tokenized_question['input_ids'],
+            'answer_ids': tokenizer_answer['input_ids']
+        }
+    
+def padding(inputs, padding_token, cutoff = None):
+    num_elems = len(inputs)
+    if cutoff is None:
+        cutoff = max([len(item) for item in inputs])
+    else:
+        cutoff = min(max([len(item) for item in inputs]), cutoff)
+    
+    tokens = torch.ones(num_elems, cutoff).long().to(inputs[0].device) * padding_token
+    for i in range(num_elems):
+        toks = inputs[i]
+        length = min(cutoff, len(toks))
+        tokens[i, -length:] = toks[-length:]
+    return tokens
+    
+@dataclass
+class PPODataCollatorWithPadding(DataCollatorWithPadding):
+    def __call__(self, features: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+        concatenated_features = {
+            'input_ids': []
+        }
+        answer_ids = []
+        for feature in features:
+            concatenated_features['input_ids'].append(feature['input_ids'])
+            answer_ids.append(torch.tensor(feature['answer_ids']))
+
+        batch = self.tokenizer.pad(
+            concatenated_features,
+            padding=self.padding,
+            max_length=self.max_length,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+            return_tensors=self.return_tensors,
+        )
+        patched_answer_ids = padding(answer_ids, 
+                padding_token=self.tokenizer.pad_token_id)
+        batch['answer_ids'] = patched_answer_ids
+        return batch
+    
+def run_ppo(
+    model_args: "ModelArguments",
+    data_args: "DataArguments",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+    generating_args: "GeneratingArguments",
+    callbacks: Optional[List["TrainerCallback"]] = None,
+):
+    tokenizer_module = load_tokenizer(model_args)
+    tokenizer = tokenizer_module["tokenizer"]
+
+    dataset = PPODataset(data_args.dataset, tokenizer, training_args)
+    
+    dist.barrier()
+    
+    model = load_model(tokenizer, model_args, finetuning_args, training_args.do_train, add_valuehead=True)
+    
+    logger.info('###model-config###')
+    logger.info(model.config)
+    
+    dist.barrier()
+
+    tokenizer.padding_side = "left"  # use left-padding in generation while using right-padding in training
+    
+    # data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+    data_collator = PPODataCollatorWithPadding(tokenizer=tokenizer, max_length=4096)
+    from torch.utils.data import DataLoader
+
+    test_loader = DataLoader(dataset,
+                              collate_fn=data_collator,
+                              sampler=None,
+                              batch_size=1)
+    for idx, d in enumerate(test_loader):
+        input_ids = d['input_ids']
+        print(tokenizer.batch_decode(input_ids), '==input==')
+        print(input_ids, '==input_ids==')
+        if idx >= 0:
+            break
+
+    # Create reference model and reward model
+    ref_model = create_ref_model(model_args, finetuning_args, add_valuehead=True)
+    reward_model = 'api'
+    
+    dist.barrier()
+
+    # Initialize our Trainer
+    ppo_trainer = CustomPPOTrainer(
+        model_args=model_args,
+        training_args=training_args,
+        finetuning_args=finetuning_args,
+        generating_args=generating_args,
+        callbacks=callbacks+[DefaultFlowCallback()],
+        model=model,
+        reward_model=reward_model,
+        ref_model=ref_model,
+        dataset=dataset,
+        data_collator=data_collator,
+        **tokenizer_module,
+    )
+    
+    dist.barrier()
+
+    # Training
+    
+    if training_args.do_train:
+        if training_args.resume_from_checkpoint:
+            ppo_trainer.ppo_train(resume_from_checkpoint=training_args.resume_from_checkpoint)
+        else:
+            ppo_trainer.ppo_train()
+        ppo_trainer.save_model()
+        if training_args.should_save:
+            my_fix_valuehead_checkpoint(model, training_args.output_dir, 
+                                        training_args.save_safetensors)
+
+        ppo_trainer.save_state()  # must be called after save_model to have a folder
+        if ppo_trainer.is_world_process_zero() and finetuning_args.plot_loss:
+            plot_loss(training_args.output_dir, keys=["loss", "reward"])
+            
+if __name__ == "__main__":
+    from llamafactory.hparams import get_infer_args, get_train_args
+    from transformers import TrainerCallback
+    from llamafactory.train.callbacks import LogCallback
+    
+    from llamafactory.hparams.data_args import DataArguments
+    from llamafactory.hparams.finetuning_args import FinetuningArguments
+    from llamafactory.hparams.model_args import ModelArguments
+    from llamafactory.hparams.generating_args import GeneratingArguments
+    
+    parser = transformers.HfArgumentParser((ModelArguments, 
+                                            DataArguments, 
+                                            Seq2SeqTrainingArguments,
+                                            FinetuningArguments,
+                                            GeneratingArguments
+                                           ))
+    
+    (model_args, data_args,
+     training_args, finetuning_args, 
+     generating_args) = parser.parse_args_into_dataclasses()
+    
+    callbacks = [LogCallback()]
+    
+    run_ppo(model_args, data_args, training_args, 
+            finetuning_args, generating_args, callbacks)

step_dpo_reward.py

@@ -0,0 +1,140 @@
+
+
+from evaluation.eval.eval_script import eval_math 
+from evaluation.data_processing.answer_extraction import extract_math_answer
+import re, json
+import argparse
+import json
+import pdb
+import jsonlines
+import os
+import torch
+
+from datasets import load_dataset
+import transformers
+
+import logging
+
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+df = load_dataset('json',
+                 data_files=['/cpfs/user/chenhao/hf_datasets/Math-Step-DPO-10K/step_dpo.jsonl'])['train']
+
+template = (
+    "Below is an instruction that describes a task. "
+    "Write a response that appropriately completes the request.\n\n"
+    "### Instruction:\n{prompt}\n\n### Response: Let's think step by step. Step 1:"
+)
+
+tokenizer = transformers.AutoTokenizer.from_pretrained(
+    '/cpfs/user/chenhao/pretrained_models/DeepSeekMath-Base-SFT/',
+    model_max_length=4096,
+    use_fast=True
+    )
+
+DATA_DICT = {}
+for d in df:
+    prompt = template.format_map(d).strip()
+    prompt_decoded = tokenizer.decode(tokenizer(prompt)['input_ids'], skip_special_tokens=True)
+    prompt_key = prompt_decoded.split('### Response:')[0].strip()
+    if prompt_key not in DATA_DICT:
+        DATA_DICT[prompt_key] = d
+        
+print(len(DATA_DICT), '==DATA_DICT==')
+
+def reward_rule_model(prompt, completion, **kwargs):
+    
+    # if kwargs.get('answer', None):
+    #     prompt_answer = kwargs['answer']
+    # else:
+    prompt_key = prompt
+    prompt_answer = DATA_DICT[prompt_key]['answer']
+    
+    if isinstance(prompt_answer, str) and prompt_answer.startswith("\\text{"):
+        prompt_answer = remove_text(prompt_answer)
+
+    if "The answer is:" in completion and (isinstance(prompt_answer, list) and len(prompt_answer) == 1 and "\\begin{pmatrix}" in prompt_answer[0]):
+        prompt_answer[0] = prompt_answer[0].replace("\\\\", "\\")
+        completion = completion.replace("\\\\", "\\")
+
+    item = {
+        'question': prompt,
+        'model_output': completion,
+        'prediction': extract_math_answer(prompt, completion, task='cot'),
+        'answer': prompt_answer if isinstance(prompt_answer, list) else [prompt_answer],
+    }
+
+#     if "The answer is:" in completion and (isinstance(prompt_answer, list) and len(prompt_answer) == 1 and "\\begin{pmatrix}" in prompt_answer[0]):
+#         prompt_answer[0] = prompt_answer[0].replace("\\\\", "\\")
+#         completion = completion.replace("\\\\", "\\")
+
+#     item = {
+#         'question': prompt,
+#         'model_output': completion,
+#         'prediction': extract_math_answer(prompt, completion, task='cot'),
+#         'answer': prompt_answer if isinstance(prompt_answer, list) else [prompt_answer],
+#     }
+
+    if len(item['prediction']) == 0:
+        return 0
+    else:
+        extract_ans = item['prediction']
+        res = eval_math(item)
+        ans_tmp = {
+            'extract_ans': extract_ans,
+            'prompt_answer': prompt_answer,
+            'res': res
+        }
+        # logger.info("########ans_tmp########")
+        # logger.info(json.dumps(ans_tmp, ensure_ascii=False))
+        # print(extract_ans, '====', prompt_answer, '====', res)
+        if res:
+            return 1
+        else:
+            return 0
+        
+def get_rewards_from_rule(prompt_list, completion_list, **kwargs):
+    rewards = []
+    if 'answers' in kwargs:
+        answer_list = kwargs['answers']
+    for idx in range(len(prompt_list)):
+        prompt = prompt_list[idx].split('### Response:')[0].strip()
+        completion = completion_list[idx]
+        if 'answers' in kwargs:
+            answer = answer_list[idx].replace('<｜begin▁of▁sentence｜>', '')
+            reward = reward_rule_model(prompt.strip(), 
+                                       completion.strip(),
+                                       answer=answer)
+        else:
+            reward = reward_rule_model(prompt.strip(), 
+                                       completion.strip())
+        rewards.append(reward)
+    reward_1 = sum([reward for reward in rewards if reward == 1])
+    # print(reward_1/(len(rewards)+1e-10), '====pass-rate====')
+    return torch.Tensor(rewards)
+
+import requests, os, time
+url = os.environ.get('RM_URL', 'http://22.5.6.221:8000/get_rm')
+s = requests.Session()
+
+def get_rewards_from_server(query, response, **kwargs):
+    r"""
+    Gets reward scores from the API server.
+    """
+    headers = {"Content-Type": "application/json"}
+    data = {
+        'prompt': query,
+        'response': response
+    }
+    for _ in range(100):
+        try:
+            response = s.post(url, json=data, headers=headers)
+            time.sleep(1.0)
+            break
+        except:
+            time.sleep(1.0)
+            continue
+    rewards = json.loads(response.text)["score"]
+    return torch.Tensor(rewards)