# Copyright 2025 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 os
import textwrap
from collections import defaultdict
from typing import Any, Callable, Optional, Union

import torch
import torch.utils.data
import torch.nn.functional as F
import transformers
from datasets import Dataset, IterableDataset
from packaging import version
from transformers import (
    AutoModel,
    AriaForConditionalGeneration,
    AriaProcessor,
    AutoModelForCausalLM,
    AutoModelForSequenceClassification,
    AutoProcessor,
    AutoTokenizer,
    GenerationConfig,
    PreTrainedModel,
    PreTrainedTokenizerBase,
    Qwen2VLForConditionalGeneration,
    Trainer,
    TrainerCallback,
    is_wandb_available,
)
from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled
from transformers.utils import is_peft_available

from trl.data_utils import apply_chat_template, is_conversational, maybe_apply_chat_template
from trl.models import create_reference_model, prepare_deepspeed, unwrap_model_for_generation
from trl.trainer.grpo_config import GRPOConfig
from trl.trainer.utils import generate_model_card, get_comet_experiment_url

import copy
import json

import logging

logger = logging.getLogger(__name__)

# from InternVL2 import load_image


if is_peft_available():
    from peft import PeftConfig, get_peft_model

if is_wandb_available():
    import wandb

# What we call a reward function is a callable that takes a list of prompts and completions and returns a list of
# rewards. When it's a string, it's a model ID, so it's loaded as a pretrained model.
RewardFunc = Union[str, PreTrainedModel, Callable[[list, list], list[float]]]


class Qwen2VLGRPOTrainer(Trainer):
    """
    Trainer for the Group Relative Policy Optimization (GRPO) method. This algorithm was initially proposed in the
    paper [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300).

    Example:

    ```python
    from datasets import load_dataset
    from trl import GRPOTrainer

    dataset = load_dataset("trl-lib/tldr", split="train")

    trainer = GRPOTrainer(
        model="Qwen/Qwen2-0.5B-Instruct",
        reward_funcs="weqweasdas/RM-Gemma-2B",
        train_dataset=dataset,
    )

    trainer.train()
    ```

    Args:
        model (`Union[str, PreTrainedModel]`):
            Model to be trained. Can be either:

            - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or
              a path to a *directory* containing model weights saved using
              [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is
              loaded using [`~transformers.AutoModelForCausalLM.from_pretrained`] with the keywork arguments
              in `args.model_init_kwargs`.
            - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported.
        reward_funcs (`Union[RewardFunc, list[RewardFunc]]`):
            Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward
            functions with the prompts and completions and sum the rewards. Can be either:

            - A single reward function, such as:
                - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a
                path to a *directory* containing model weights saved using
                [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded
                using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the
                keyword arguments in `args.model_init_kwargs`.
                - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported.
                - A custom reward function: The function is provided with the prompts and the generated completions,
                  plus any additional columns in the dataset. It should return a list of rewards. For more details, see
                  [Using a custom reward function](#using-a-custom-reward-function).
            - A list of reward functions, where each item can independently be any of the above types. Mixing different
            types within the list (e.g., a string model ID and a custom reward function) is allowed.
        args ([`GRPOConfig`], *optional*, defaults to `None`):
            Configuration for this trainer. If `None`, a default configuration is used.
        train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]):
            Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is
            ignored. The format of the samples can be either:

            - [Standard](dataset_formats#standard): Each sample contains plain text.
            - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role
              and content).
        eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Union[Dataset, IterableDataset]]`):
            Dataset to use for evaluation. It must meet the same requirements as `train_dataset`.
        processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*, defaults to `None`):
            Processing class used to process the data. The padding side must be set to "left". If `None`, the
            processing class is loaded from the model's name with [`~transformers.AutoTokenizer.from_pretrained`].
        reward_processing_classes (`Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]`, *optional*, defaults to `None`):
            Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either:

            - A single processing class: Used when `reward_funcs` contains only one reward function.
            - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`.
            If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is
            `None`, the tokenizer for the model is automatically loaded using [`~transformers.AutoTokenizer.from_pretrained`].
            For elements in `reward_funcs` that are custom reward functions (not [`~transformers.PreTrainedModel`]),
            the corresponding entries in `reward_processing_classes` are ignored.
        callbacks (list of [`~transformers.TrainerCallback`], *optional*, defaults to `None`):
            List of callbacks to customize the training loop. Will add those to the list of default callbacks
            detailed in [here](https://huggingface.co/docs/transformers/main_classes/callback).

            If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`]
            method.
        optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`, *optional*, defaults to `(None, None)`):
            A tuple containing the optimizer and the scheduler to use. Will default to an instance of [`AdamW`] on your
            model and a scheduler given by [`get_linear_schedule_with_warmup`] controlled by `args`.
        peft_config ([`~peft.PeftConfig`], *optional*, defaults to `None`):
            PEFT configuration used to wrap the model. If `None`, the model is not wrapped.
    """

    def __init__(
        self,
        model: Union[str, PreTrainedModel],
        reward_funcs: Union[RewardFunc, list[RewardFunc]],
        args: GRPOConfig = None,
        train_dataset: Optional[Union[Dataset, IterableDataset]] = None,
        eval_dataset: Optional[Union[Dataset, IterableDataset, dict[str, Union[Dataset, IterableDataset]]]] = None,
        processing_class: Optional[PreTrainedTokenizerBase] = None,
        reward_processing_classes: Optional[Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]] = None,
        callbacks: Optional[list[TrainerCallback]] = None,
        optimizers: tuple[Optional[torch.optim.Optimizer], Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None),
        peft_config: Optional["PeftConfig"] = None,
        max_pixels: Optional[int] = 12845056,
        min_pixels: Optional[int] = 3136,
        attn_implementation: str = "flash_attention_2",
    ):
        # Args
        if args is None:
            model_name = model if isinstance(model, str) else model.config._name_or_path
            model_name = model_name.split("/")[-1]
            args = GRPOConfig(f"{model_name}-GRPO")

        # Models
        # Trained model
        model_init_kwargs = args.model_init_kwargs or {}
        model_init_kwargs["attn_implementation"] = attn_implementation
        if isinstance(model, str):
            model_id = model
            torch_dtype = model_init_kwargs.get("torch_dtype")
            if isinstance(torch_dtype, torch.dtype) or torch_dtype == "auto" or torch_dtype is None:
                pass  # torch_dtype is already a torch.dtype or "auto" or None
            elif isinstance(torch_dtype, str):  # it's a str, but not "auto"
                torch_dtype = getattr(torch, torch_dtype)
                model_init_kwargs["torch_dtype"] = torch_dtype
            else:
                raise ValueError(
                    "Invalid `torch_dtype` passed to `GRPOConfig`. Expected either 'auto' or a string representing "
                    f"a `torch.dtype` (e.g., 'float32'), but got {torch_dtype}."
                )
            # Disable caching if gradient checkpointing is enabled (not supported)
            model_init_kwargs["use_cache"] = (
                False if args.gradient_checkpointing else model_init_kwargs.get("use_cache")
            )
            if "Qwen2-VL" in model_id:
                model = Qwen2VLForConditionalGeneration.from_pretrained(model, **model_init_kwargs)
            elif "Aria" in model_id:
                model_init_kwargs.pop("use_cache")
                model = AriaForConditionalGeneration.from_pretrained(model, **model_init_kwargs)
            elif "InternVL2" in model_id:
                model_init_kwargs.pop("use_cache")
                model = AutoModel.from_pretrained(model, trust_remote_code=True, **model_init_kwargs)
            else:
                model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs)
        else:
            model_id = model.config._name_or_path
            if args.model_init_kwargs is not None:
                raise ValueError(
                    "You passed `model_init_kwargs` to the `GRPOConfig`, but your model is already instantiated. "
                    "This argument can only be used when the `model` argument is a string."
                )

        if peft_config is not None:
            model = get_peft_model(model, peft_config)

        # Reference model
        if is_deepspeed_zero3_enabled():
            if "Qwen2-VL" in model_id:
                self.ref_model = Qwen2VLForConditionalGeneration.from_pretrained(model_id, **model_init_kwargs)
            elif "Aria" in model_id:
                self.ref_model = AriaForConditionalGeneration.from_pretrained(model_id, **model_init_kwargs)
            elif "InternVL2" in model_id:
                self.ref_model = AutoModel.from_pretrained(model_id, trust_remote_code=True, **model_init_kwargs)
            else:
                self.ref_model = AutoModelForCausalLM.from_pretrained(model_id, **model_init_kwargs)
        elif peft_config is None:
            # If PEFT configuration is not provided, create a reference model based on the initial model.
            self.ref_model = create_reference_model(model)
        else:
            # If PEFT is used, the reference model is not needed since the adapter can be disabled
            # to revert to the initial model.
            self.ref_model = None

        # Processing class
        if processing_class is None:
            if "Qwen2-VL" in model_id or "Aria" in model_id:
                processing_class = AutoProcessor.from_pretrained(model_id)
                pad_token_id = processing_class.tokenizer.pad_token_id
                processing_class.pad_token_id = pad_token_id
                processing_class.eos_token_id = processing_class.tokenizer.eos_token_id
                if "Qwen2-VL" in model_id:
                    processing_class.image_processor.max_pixels = max_pixels
                    processing_class.image_processor.min_pixels = min_pixels
            elif "InternVL2" in model_id:
                processing_class = AutoTokenizer.from_pretrained(model.config._name_or_path, trust_remote_code=True, padding_side="left")
                pad_token_id = processing_class.pad_token_id
            else:
                processing_class = AutoTokenizer.from_pretrained(model.config._name_or_path, padding_side="left")
                pad_token_id = processing_class.pad_token_id

        # Reward functions
        if not isinstance(reward_funcs, list):
            reward_funcs = [reward_funcs]
        for i, reward_func in enumerate(reward_funcs):
            if isinstance(reward_func, str):
                reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained(
                    reward_func, num_labels=1, **model_init_kwargs
                )
        self.reward_funcs = reward_funcs

        # Reward processing class
        if reward_processing_classes is None:
            reward_processing_classes = [None] * len(reward_funcs)
        elif not isinstance(reward_processing_classes, list):
            reward_processing_classes = [reward_processing_classes]
        else:
            if len(reward_processing_classes) != len(reward_funcs):
                raise ValueError("The number of reward processing classes must match the number of reward functions.")

        for i, (reward_processing_class, reward_func) in enumerate(zip(reward_processing_classes, reward_funcs)):
            if isinstance(reward_func, PreTrainedModel):
                if reward_processing_class is None:
                    reward_processing_class = AutoTokenizer.from_pretrained(reward_func.config._name_or_path)
                if reward_processing_class.pad_token_id is None:
                    reward_processing_class.pad_token = reward_processing_class.eos_token
                # The reward model computes the reward for the latest non-padded token in the input sequence.
                # So it's important to set the pad token ID to the padding token ID of the processing class.
                reward_func.config.pad_token_id = reward_processing_class.pad_token_id
                reward_processing_classes[i] = reward_processing_class
        self.reward_processing_classes = reward_processing_classes

        # Data collator
        def data_collator(features):  # No data collation is needed in GRPO
            return features

        # Training arguments
        self.max_prompt_length = args.max_prompt_length
        self.max_completion_length = args.max_completion_length  # = |o_i| in the GRPO paper
        self.num_generations = args.num_generations  # = G in the GRPO paper
        self.generation_config = GenerationConfig(
            max_new_tokens=self.max_completion_length,
            do_sample=True,  
            temperature=1, # HACK
            num_return_sequences=self.num_generations,
            pad_token_id=pad_token_id,
        )
        self.beta = args.beta

        # The trainer estimates the number of FLOPs (floating-point operations) using the number of elements in the
        # input tensor associated with the key "input_ids". However, in GRPO, the sampled data does not include the
        # "input_ids" key. Instead, the available keys is "prompt". As a result, the trainer issues the warning:
        # "Could not estimate the number of tokens of the input, floating-point operations will not be computed." To
        # suppress this warning, we set the "estimate_tokens" key in the model's "warnings_issued" dictionary to True.
        # This acts as a flag to indicate that the warning has already been issued.
        model.warnings_issued["estimate_tokens"] = True

        # Initialize the metrics
        self._metrics = defaultdict(list)

        super().__init__(
            model=model,
            args=args,
            data_collator=data_collator,
            train_dataset=train_dataset,
            eval_dataset=eval_dataset,
            processing_class=processing_class,
            callbacks=callbacks,
            optimizers=optimizers,
        )

        # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the
        # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set
        # self.model_accepts_loss_kwargs to False to enable scaling.
        self.model_accepts_loss_kwargs = False

        if self.ref_model is not None:
            if self.is_deepspeed_enabled:
                self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator)
            else:
                self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True)

        for i, reward_func in enumerate(self.reward_funcs):
            if isinstance(reward_func, PreTrainedModel):
                self.reward_funcs[i] = self.accelerator.prepare_model(reward_func, evaluation_mode=True)

        # set re-sample dataloader
        self._current_epoch_dataloader = None
        self._current_epoch_iterator = None


    def _set_signature_columns_if_needed(self):
        # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
        # By default, this method sets `self._signature_columns` to the model's expected inputs.
        # In GRPOTrainer, we preprocess data, so using the model's signature columns doesn't work.
        # Instead, we set them to the columns expected by the `training_step` method, hence the override.
        if self._signature_columns is None:
            self._signature_columns = ["prompt"]


    # Get the per-token log probabilities for the completions for the model and the reference model
    def _get_per_token_logps(self, model, input_ids, attention_mask, pixel_values, image_grid_thw):
        logits = model(input_ids, attention_mask=attention_mask, pixel_values=pixel_values, image_grid_thw=image_grid_thw).logits  # (B, L, V)
        logits = logits[:, :-1, :]  # (B, L-1, V), exclude the last logit: it corresponds to the next token pred
        input_ids = input_ids[:, 1:]  # (B, L-1), exclude the first input ID since we don't have logits for it
        # Compute the log probabilities for the input tokens. Use a loop to reduce memory peak.
        per_token_logps = []
        for logits_row, input_ids_row in zip(logits, input_ids):
            log_probs = logits_row.log_softmax(dim=-1)
            token_log_prob = torch.gather(log_probs, dim=1, index=input_ids_row.unsqueeze(1)).squeeze(1)
            per_token_logps.append(token_log_prob)
        return torch.stack(per_token_logps)

    def get_local_batch_samples(self, epoch_iterator, num_batches):
        batch_samples = []
        num_items_in_batch = None
        end = False
        for _ in range(num_batches):
            try:
                batch_samples += [next(epoch_iterator)]
            except StopIteration:
                end = True
                break

        if len(batch_samples) > 0 and "labels" in batch_samples[0]:
            # For now we don't support object detection
            try:
                num_items_in_batch = sum([(batch["labels"].ne(-100)).sum() for batch in batch_samples])
            except (TypeError, AttributeError):
                pass

        if self.args.average_tokens_across_devices and num_items_in_batch is not None:
            num_items_in_batch = self.accelerator.gather(num_items_in_batch).sum().item()

        if torch.is_tensor(num_items_in_batch):
            num_items_in_batch = num_items_in_batch.item()

        return batch_samples, num_items_in_batch, end
    
    def get_train_dataloader(self):
        dataloader = super().get_train_dataloader()
        self._current_epoch_dataloader = dataloader
        try:
            self._current_epoch_iterator = iter(dataloader)
            logger.info("Captured current epoch dataloader and iterator for GPG-style resampling.")
        except Exception:
            self._current_epoch_iterator = None
            logger.warning("Failed to capture current epoch dataloader and iterator for GPG-style resampling.")
        return dataloader

    # Trainer "prepares" the inputs before calling `compute_loss`. It converts to tensor and move to device.
    # Since we preprocess the data in `compute_loss`, we need to override this method to skip this step.
    def _prepare_inputs(self, inputs: dict[str, Union[torch.Tensor, Any]]) -> dict[str, Union[torch.Tensor, Any]]:
        return inputs


    def _generate_and_score_completions(
        self, model, inputs: dict[str, Union[torch.Tensor, Any]]
    ) -> dict[str, Union[torch.Tensor, Any]]:
        max_resample_attempts = 20
        n_valid_samples = 0
        device = self.accelerator.device
        new_rewards_per_func = None
        new_rewards = None
        new_prompt_ids = None
        new_prompt_mask = None
        new_completion_ids = None
        new_completion_mask = None
        new_pixel_values = None
        new_image_grid_thw = None

        for current_resample_attempt in range(max_resample_attempts):
            if current_resample_attempt != 0 or len(inputs) == 0:
                batch_samples, num_items_in_batch, end = self.get_local_batch_samples(self._current_epoch_iterator, 1)
                if end:
                    self._current_epoch_iterator = iter(self._current_epoch_dataloader)
                    batch_samples, num_items_in_batch, end = self.get_local_batch_samples(self._current_epoch_iterator, 1)
                inputs = batch_samples[0]
            
            prompts = [x["prompt"] for x in inputs]
            prompts_text = [apply_chat_template(example, self.processing_class)["prompt"] for example in inputs]
            images = [x["image"] for x in inputs]
            prompt_inputs = self.processing_class(
                text=prompts_text,
                images=images,
                return_tensors="pt",
                padding=True,
                padding_side="left",
                add_special_tokens=False,
            )
            prompt_inputs = super()._prepare_inputs(prompt_inputs)
            
            prompt_ids, prompt_mask = prompt_inputs["input_ids"], prompt_inputs["attention_mask"]
            pixel_values = prompt_inputs["pixel_values"]
            image_grid_thw = prompt_inputs["image_grid_thw"]

            if self.max_prompt_length is not None:
                prompt_ids = prompt_ids[:, -self.max_prompt_length :]
                prompt_mask = prompt_mask[:, -self.max_prompt_length :]

            # Generate completions
            with unwrap_model_for_generation(model, self.accelerator) as unwrapped_model:
                #prompt_completion_ids = unwrapped_model.generate(**prompt_inputs, generation_config=self.generation_config)
                # Generate N times, each generate one with the temp_generation_config , stack the output_ids to prompt_completion_ids, pad the empty places with number 151613
                num_generations = self.generation_config.num_return_sequences
                temp_generation_config = copy.deepcopy(self.generation_config)
                temp_generation_config.num_return_sequences = 1

                all_completions = []

                for i in range(num_generations):  # -1 because we already have one generation
                    completion = unwrapped_model.generate(**prompt_inputs, generation_config=temp_generation_config)
                    all_completions.append(completion)
                
                # Stack all completions and pad if needed
                max_length = max(completion.size(1) for completion in all_completions)
                padded_completions = []

                for completion in all_completions:
                    if completion.size(1) < max_length:
                        padding = torch.full((completion.size(0), max_length - completion.size(1)), 
                                        self.processing_class.tokenizer.pad_token_id, 
                                        dtype=completion.dtype,
                                        device=completion.device)
                        padded_completion = torch.cat([completion, padding], dim=1)
                    else:
                        padded_completion = completion
                    padded_completions.append(padded_completion)

                # Stack all padded completions
                prompt_completion_ids = torch.cat(padded_completions, dim=0)

                prompt_length = prompt_ids.size(1)
                prompt_ids = prompt_completion_ids[:, :prompt_length]
                completion_ids = prompt_completion_ids[:, prompt_length:]
                prompt_mask = prompt_mask.repeat_interleave(self.num_generations, dim=0)

            # Mask everything after the first EOS token
            is_eos = completion_ids == self.processing_class.eos_token_id
            device = self.accelerator.device
            eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
            eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
            sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
            completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int()

            # Concatenate prompt_mask with completion_mask for logit computation
            attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)  # (B*G, P+C)
            pixel_values = prompt_inputs["pixel_values"][None].repeat_interleave(self.num_generations, dim=0)
            image_grid_thw = prompt_inputs["image_grid_thw"].repeat_interleave(self.num_generations, dim=0)

            # Decode the generated completions
            completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
            if is_conversational(inputs[0]):
                completions = [[{"role": "assistant", "content": completion}] for completion in completions]

            # Compute the rewards
            prompts = [prompt for prompt in prompts for _ in range(self.num_generations)]

            rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device)
            for i, (reward_func, reward_processing_class) in enumerate(
                zip(self.reward_funcs, self.reward_processing_classes)
            ):
                if isinstance(reward_func, PreTrainedModel):
                    if is_conversational(inputs[0]):
                        messages = [{"messages": p + c} for p, c in zip(prompts, completions)]
                        texts = [apply_chat_template(x, reward_processing_class)["text"] for x in messages]
                    else:
                        texts = [p + c for p, c in zip(prompts, completions)]
                    reward_inputs = reward_processing_class(
                        texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False
                    )
                    reward_inputs = super()._prepare_inputs(reward_inputs)
                    with torch.inference_mode():
                        rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0]  # Shape (B*G,)
                else:
                    # Repeat all input columns (but "prompt" and "completion") to match the number of generations
                    reward_kwargs = {key: [] for key in inputs[0].keys() if key not in ["prompt", "completion"]}
                    for key in reward_kwargs:
                        for example in inputs:
                            # Repeat each value in the column for `num_generations` times
                            reward_kwargs[key].extend([example[key]] * self.num_generations)
                    output_reward_func = reward_func(prompts=prompts, completions=completions, **reward_kwargs)
                    rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device)

            # Sum the rewards from all reward functions
            rewards = rewards_per_func.sum(dim=1)

            log_trajectories = True
            if log_trajectories:
                save_dir = f"trajectories/trajectories_{self.args.run_name}/step{self.state.global_step}"
                os.makedirs(save_dir, exist_ok=True)
                save_path = os.path.join(save_dir, f"rank{self.accelerator.process_index}.jsonl")
                with open(save_path, "w") as f:
                    json.dump({
                        'trajectories': [{"messages": {"prompt": p[0], "response": c[0]} if len(p) == 1 else {"prompt": p[1]['text'], "response":c}, "solution": inputs[0]['solution'], "reward": r} for p, c, r in zip(prompts, completions, rewards.view(self.num_generations).tolist())],
                    }, f, indent=2)

            with torch.inference_mode():
                gathered_rewards_per_func = self.accelerator.gather(rewards_per_func)
                gathered_rewards = gathered_rewards_per_func.sum(dim=1)

                gathered_mean_grouped_rewards = gathered_rewards.view(-1, self.num_generations).mean(dim=1)
                gathered_std_grouped_rewards = gathered_rewards.view(-1, self.num_generations).std(dim=1)

                # 找出标准差为 0 的组
                identical_value_mask = gathered_std_grouped_rewards <= 1e-5
                easy_mask = gathered_mean_grouped_rewards >= len(self.reward_funcs) - 1e-5
                hard_mask = gathered_mean_grouped_rewards <= 1e-5

                # 计算标准差为 0 的组的数目
                num_identical_reward_groups = identical_value_mask.sum().item()
                num_easy_problem = easy_mask.sum().item()
                num_hard_problem = hard_mask.sum().item()
                num_reward_samples = gathered_std_grouped_rewards.numel()

                # lr_ratio = num_identical_reward_groups / num_reward_samples
                n_valid_samples += num_reward_samples - num_identical_reward_groups

            
            my_rewards_stds = rewards.view(-1, self.num_generations).std(dim=1)

            my_valid_value_mask = torch.where(my_rewards_stds > 0)[0]
            my_identical_value_mask = torch.where(my_rewards_stds == 0)[0]

            num_questions = len(prompts) // self.num_generations
            _b_valid = my_valid_value_mask.shape[0] * self.num_generations
            _b_ident = my_identical_value_mask.shape[0] * self.num_generations
            assert _b_valid + _b_ident == len(prompts)

            # prompt_completion_ids, attention_mask 这两个使用拼接的方式构建出来
            # pixel_values, image_grid_thw 这两个直接保存
            if _b_valid > 0:
                valid_rewards = rewards.reshape(num_questions, self.num_generations)[my_valid_value_mask].reshape(_b_valid)
                valid_prompt_ids = prompt_ids.reshape(num_questions, self.num_generations, -1)[my_valid_value_mask].reshape(_b_valid, -1)
                valid_prompt_mask = prompt_mask.reshape(num_questions, self.num_generations, -1)[my_valid_value_mask].reshape(_b_valid, -1)
                valid_completion_ids = completion_ids.reshape(num_questions, self.num_generations, -1)[
                    my_valid_value_mask].reshape(_b_valid, -1)
                valid_completion_mask = completion_mask.reshape(num_questions, self.num_generations, -1)[
                    my_valid_value_mask].reshape(_b_valid, -1)
                
                # 先这样处理，如果遇到valid_image_grid_thw中图片thw不一致，那么需要专门处理
                valid_pixel_values = pixel_values.reshape(num_questions, self.num_generations, -1, pixel_values.shape[-1])[
                    my_valid_value_mask].reshape(-1, pixel_values.shape[-1])
                valid_image_grid_thw = image_grid_thw.reshape(num_questions, self.num_generations, -1)[my_valid_value_mask].reshape(_b_valid, -1)

                # rewards_per_func
                valid_rewards_per_func = rewards_per_func.reshape(num_questions, self.num_generations, -1)[
                    my_valid_value_mask].reshape(_b_valid, -1)
            else:
                valid_rewards, valid_prompt_ids, valid_prompt_mask, valid_completion_ids, valid_completion_mask, valid_pixel_values, \
                    valid_image_grid_thw, valid_rewards_per_func = [None] * 8
                
            if _b_ident > 0:
                identical_rewards = rewards.reshape(num_questions, self.num_generations)[
                    my_identical_value_mask].reshape(_b_ident)
                identical_prompt_ids = prompt_ids.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
                identical_prompt_mask = prompt_mask.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
                identical_completion_ids = completion_ids.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
                identical_completion_mask = completion_mask.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
                # 先这样处理，如果遇到identical_image_grid_thw中图片thw不一致，那么需要专门处理
                identical_pixel_values = pixel_values.reshape(num_questions, self.num_generations, -1, pixel_values.shape[-1])[
                    my_identical_value_mask].reshape(-1, pixel_values.shape[-1])
                identical_image_grid_thw = image_grid_thw.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
                
                identical_rewards_per_func = rewards_per_func.reshape(num_questions, self.num_generations, -1)[
                    my_identical_value_mask].reshape(_b_ident, -1)
            else:
                identical_rewards, identical_prompt_ids, identical_prompt_mask, identical_completion_ids, identical_completion_mask, identical_pixel_values, \
                    identical_image_grid_thw, identical_rewards_per_func = [None] * 8

            new_rewards = d_concat(new_rewards, valid_rewards)
            new_prompt_mask = d_concat_with_padding(new_prompt_mask, valid_prompt_mask, 0, left_pad=True)
            new_prompt_ids = d_concat_with_padding(new_prompt_ids, valid_prompt_ids, self.processing_class.pad_token_id, left_pad=True)
            new_completion_mask = d_concat_with_padding(new_completion_mask, valid_completion_mask, 0, left_pad=False)
            new_completion_ids = d_concat_with_padding(new_completion_ids, valid_completion_ids, self.processing_class.pad_token_id, left_pad=False)

            new_image_grid_thw = d_concat(new_image_grid_thw, valid_image_grid_thw)
            new_pixel_values = d_concat(new_pixel_values, valid_pixel_values)

            new_rewards_per_func = d_concat(new_rewards_per_func, valid_rewards_per_func)

            if n_valid_samples < self.args.min_inverse_alpha * num_reward_samples and current_resample_attempt != max_resample_attempts - 1:
                logger.info(f"keep generating more examples: the {current_resample_attempt}-th mini-batch")
                continue

            # 重新组装样本batch
            rewards = d_concat(new_rewards, identical_rewards)[:len(prompts)]
            prompt_mask = d_concat_with_padding(new_prompt_mask, identical_prompt_mask, 0, left_pad=True)[:len(prompts)]
            prompt_ids = d_concat_with_padding(new_prompt_ids, identical_prompt_ids, self.processing_class.pad_token_id, left_pad=True)[:len(prompts)]
            completion_mask = d_concat_with_padding(new_completion_mask, identical_completion_mask, 0, left_pad=False)[:len(prompts)]
            completion_ids = d_concat_with_padding(new_completion_ids, identical_completion_ids, self.processing_class.pad_token_id, left_pad=False)[:len(prompts)]

            image_grid_thw = d_concat(new_image_grid_thw, identical_image_grid_thw)[:len(prompts)]
            pixel_values_num = torch.sum(torch.prod(image_grid_thw, dim=1))
            pixel_values = d_concat(new_pixel_values, identical_pixel_values)[:pixel_values_num]

            rewards_per_func = d_concat(new_rewards_per_func, identical_rewards_per_func)[:len(prompts)]

            break

        mean_grouped_rewards = rewards.view(-1, self.num_generations).mean(dim=1)
        std_grouped_rewards = rewards.view(-1, self.num_generations).std(dim=1)

        # Normalize the rewards to compute the advantages
        mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
        std_grouped_rewards = std_grouped_rewards.repeat_interleave(self.num_generations, dim=0)

        if self.args.adjust_gd:
            advantages = (rewards - mean_grouped_rewards)
        else:
            advantages = (rewards - mean_grouped_rewards) / (std_grouped_rewards + 1e-4)

        inverse_alpha = n_valid_samples / num_reward_samples
        inverse_alpha = min(1.0, inverse_alpha)

        return {
            "rewards": rewards,
            "advantages": advantages,
            "rewards_per_func": rewards_per_func,
            "std_grouped_rewards": std_grouped_rewards,
            "n_valid_samples": n_valid_samples,
            "num_reward_samples": num_reward_samples,

            "prompt_mask": prompt_mask,
            "prompt_ids": prompt_ids,
            "completion_mask": completion_mask,
            "completion_ids": completion_ids,
            "pixel_values": pixel_values,
            "image_grid_thw": image_grid_thw,
            "inverse_alpha": inverse_alpha,
            
            "current_resample_attempt": current_resample_attempt,

        }


    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        if return_outputs:
            raise ValueError("The GRPOTrainer does not support returning outputs")

        inputs = self._generate_and_score_completions(model, inputs)
        prompt_completion_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1)
        completion_mask = inputs["completion_mask"]
        attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1)
        pixel_values = inputs["pixel_values"]
        image_grid_thw = inputs["image_grid_thw"]
        prompt_length = inputs["prompt_ids"].size(1)

        rewards = inputs["rewards"]
        advantages = inputs["advantages"]
        rewards_per_func = inputs["rewards_per_func"]
        std_grouped_rewards = inputs["std_grouped_rewards"]

        inverse_alpha = inputs["inverse_alpha"]

        n_valid_samples = inputs["n_valid_samples"]
        num_reward_samples = inputs["num_reward_samples"]

        current_resample_attempt = inputs["current_resample_attempt"]


        per_token_logps = self._get_per_token_logps(model, prompt_completion_ids, attention_mask, pixel_values, image_grid_thw)
        # Get rid of the prompt (-1 because of the shift done in get_per_token_logps)
        per_token_logps = per_token_logps[:, prompt_length - 1 :]

        # if self.args.pg_name in ['grpo', 'pinsker']:
        with torch.inference_mode():
            if self.ref_model is not None:
                ref_per_token_logps = self._get_per_token_logps(self.ref_model, prompt_completion_ids, attention_mask, pixel_values, image_grid_thw)
            else:
                with self.accelerator.unwrap_model(model).disable_adapter():
                    ref_per_token_logps = self._get_per_token_logps(model, prompt_completion_ids, attention_mask, pixel_values, image_grid_thw)
        ref_per_token_logps = ref_per_token_logps[:, prompt_length - 1 :]


        if self.args.pg_name == 'grpo':
            # Compute the KL divergence between the model and the reference model
            per_token_kl = torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
            # x - x.detach() allows for preserving gradients from x
            per_token_loss = torch.exp(per_token_logps - per_token_logps.detach()) * advantages.unsqueeze(1)
            per_token_loss = -(per_token_loss - self.beta * per_token_kl)
            loss = ((per_token_loss * completion_mask).sum(dim=1) / completion_mask.sum(dim=1)).mean()

        elif self.args.pg_name == 'gpg':
            per_token_loss = - per_token_logps * advantages.unsqueeze(1)
            loss = ((per_token_loss * completion_mask).sum(dim=1) / completion_mask.sum(dim=1)).mean()
        else:
            raise ValueError(f"Unknown policy gradient name: {self.args.pg_name}")

        # Log the metrics
        completion_length = self.accelerator.gather_for_metrics(completion_mask.sum(1)).float().mean().item()
        self._metrics["completion_length"].append(completion_length)

        reward_per_func = self.accelerator.gather_for_metrics(rewards_per_func).mean(0)
        for i, reward_func in enumerate(self.reward_funcs):
            if isinstance(reward_func, PreTrainedModel):
                reward_func_name = reward_func.config._name_or_path.split("/")[-1]
            else:
                reward_func_name = reward_func.__name__
            self._metrics[f"rewards/{reward_func_name}"].append(reward_per_func[i].item())

        self._metrics["reward"].append(self.accelerator.gather_for_metrics(rewards).mean().item())

        self._metrics["reward_std"].append(self.accelerator.gather_for_metrics(std_grouped_rewards).mean().item())

        self._metrics['n_valid_samples'].append(n_valid_samples)
        self._metrics['n_reward_samples'].append(num_reward_samples)
        self._metrics['inverse_alpha'].append(inverse_alpha)
        self._metrics['current_resample_attempt'].append(current_resample_attempt)

        if self.args.pg_name == 'grpo':
            mean_kl = ((per_token_kl * completion_mask).sum(dim=1) / completion_mask.sum(dim=1)).mean()
            self._metrics["kl"].append(self.accelerator.gather_for_metrics(mean_kl).mean().item())
        elif self.args.pg_name == 'gpg':
            # mean_kl = 0.0
            per_token_kl = torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
            mean_kl = ((per_token_kl * completion_mask).sum(dim=1) / completion_mask.sum(dim=1)).mean()
            self._metrics["kl_gpg"].append(self.accelerator.gather_for_metrics(mean_kl).mean().item())

        if self.args.adjust_gd:
            loss = loss / (inverse_alpha + 1e-5)
        return loss

    def log(self, logs: dict[str, float], start_time: Optional[float] = None) -> None:
        metrics = {key: sum(val) / len(val) for key, val in self._metrics.items()}  # average the metrics
        logs = {**logs, **metrics}
        if version.parse(transformers.__version__) >= version.parse("4.47.0.dev0"):
            super().log(logs, start_time)
        else:  # transformers<=4.46
            super().log(logs)
        self._metrics.clear()

    def create_model_card(
        self,
        model_name: Optional[str] = None,
        dataset_name: Optional[str] = None,
        tags: Union[str, list[str], None] = None,
    ):
        """
        Creates a draft of a model card using the information available to the `Trainer`.

        Args:
            model_name (`str` or `None`, *optional*, defaults to `None`):
                Name of the model.
            dataset_name (`str` or `None`, *optional*, defaults to `None`):
                Name of the dataset used for training.
            tags (`str`, `list[str]` or `None`, *optional*, defaults to `None`):
                Tags to be associated with the model card.
        """
        if not self.is_world_process_zero():
            return

        if hasattr(self.model.config, "_name_or_path") and not os.path.isdir(self.model.config._name_or_path):
            base_model = self.model.config._name_or_path
        else:
            base_model = None

        tags = tags or []
        if isinstance(tags, str):
            tags = [tags]

        if hasattr(self.model.config, "unsloth_version"):
            tags.append("unsloth")

        citation = textwrap.dedent(
            """\
            @article{zhihong2024deepseekmath,
                title        = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}},
                author       = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo},
                year         = 2024,
                eprint       = {arXiv:2402.03300},
            """
        )

        model_card = generate_model_card(
            base_model=base_model,
            model_name=model_name,
            hub_model_id=self.hub_model_id,
            dataset_name=dataset_name,
            tags=tags,
            wandb_url=wandb.run.get_url() if is_wandb_available() and wandb.run is not None else None,
            comet_url=get_comet_experiment_url(),
            trainer_name="GRPO",
            trainer_citation=citation,
            paper_title="DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models",
            paper_id="2402.03300",
        )

        model_card.save(os.path.join(self.args.output_dir, "README.md"))

def d_concat(old_d, new_d):
    if new_d is None:
        return old_d
    if old_d is None:
        return new_d
    
    return torch.concat([old_d, new_d])


def d_concat_with_padding(old_d, new_d, pad_token_id, left_pad=False):
    if new_d is None:
        return old_d
    if old_d is None:
        return new_d
    
    if new_d.shape[1] < old_d.shape[1]:
        new_d = pad_sequence_to_length(new_d, old_d.shape[1], pad_token_id, left_pad)
    else:
        old_d = pad_sequence_to_length(old_d, new_d.shape[1], pad_token_id, left_pad)
    
    return torch.concat([old_d, new_d])

def pad_sequence_to_length(tensors, max_seq_len, pad_token_id, left_pad=False):
    """
    pad a 2D tensors (e.g. responses, logprobs) in the last dim to max_seq_length.
    input shape: [bs, seq_length]
    output shape: [bs, max_seq_length]
    (0, max_seq_len - tensors.shape[-1]) means right pad to max_seq_length and no left pad
    """
    if tensors.shape[-1] >= max_seq_len:
        return tensors
    pad_tuple = (max_seq_len - tensors.shape[-1], 0) if left_pad else (0, max_seq_len - tensors.shape[-1])
    return F.pad(tensors, pad_tuple, "constant", pad_token_id)
