Upload BA agent post-training scripts

README.md

@@ -0,0 +1,83 @@
+# BA Agent Post-Training Experiment
+
+This directory is a standalone experiment workspace copied out of the main training path.
+
+Training objective:
+
+- Keep `data_insight` isolated from long-chain planning and report writing.
+- Reuse one shared base model with role-specific LoRA adapters.
+- Optimize evidence-grounded analysis and conclusion reliability before attempting long-report end-to-end RL.
+
+Recommended order:
+
+1. Train `data_insight` with SFT.
+2. Train `writer` with SFT.
+3. Run `writer` DPO and reward modeling on BA preference data.
+4. Optionally run PPO with the reward adapter on prompt-only tasks.
+
+Supported SFT schema:
+
+```json
+{"system":"optional role prompt","prompt":"question or analysis context","response":"target answer"}
+```
+
+Supported automatically:
+
+- `instruction` + `input` + `output`
+- `question` + `answer`
+- `messages` / `conversations` where the final assistant turn is the target
+
+Supported DPO / reward schema:
+
+```json
+{"system":"optional role prompt","prompt":"same prompt shown to both candidates","chosen":"preferred answer","rejected":"dispreferred answer"}
+```
+
+Supported automatically:
+
+- `question` + `response_chosen` + `response_rejected`
+- `Anthropic/hh-rlhf` style `chosen` / `rejected`
+- `PKU-Alignment/PKU-SafeRLHF-*` style pairwise columns
+
+Supported PPO prompt schema:
+
+```json
+{"system":"optional role prompt","prompt":"generation prompt only"}
+```
+
+Suggested role split:
+
+- `data_insight`: facts, supported insights, evidence refs, uncertainty only
+- `writer`: briefs, chatbot answers, and section drafts that consume structured evidence
+
+Files in this experiment:
+
+- `utils.py`: local copy of shared training helpers and arguments
+- `data_adapter.py`: local schema normalizer for SFT / DPO / reward / PPO
+- `sft.py`, `dpo.py`, `reward_model.py`, `ppo_multi_adapter.py`: experiment training entrypoints
+- `merge_adapter.py`, `ma_ppo_config.py`, `ma_ppo_trainer.py`: copied dependencies needed by this experiment
+- `data/*.sample.jsonl`: schema examples and smoke-test inputs
+- `scripts/run_ba_role_*.sh`: standalone run scripts
+
+Quick start:
+
+```bash
+bash ./experiments/ba_agent_posttrain/scripts/run_ba_role_sft.sh \
+  ROLE_NAME=data_insight \
+  SFT_DATASET_NAME=./experiments/ba_agent_posttrain/data/data_insight_sft.sample.jsonl
+
+bash ./experiments/ba_agent_posttrain/scripts/run_ba_role_sft.sh \
+  ROLE_NAME=writer \
+  SFT_DATASET_NAME=./experiments/ba_agent_posttrain/data/writer_sft.sample.jsonl
+
+bash ./experiments/ba_agent_posttrain/scripts/run_ba_role_dpo.sh \
+  ROLE_NAME=writer \
+  PREFERENCE_DATASET_NAME=./experiments/ba_agent_posttrain/data/writer_preference.sample.jsonl
+```
+
+For real runs, replace the sample files with your own:
+
+- `data_insight_sft.jsonl`
+- `writer_sft.jsonl`
+- `writer_preference.jsonl`
+- `writer_prompts.jsonl`

config/ds.json

@@ -0,0 +1,6 @@
+{
+  "train_micro_batch_size_per_gpu": "auto",
+  "zero_optimization": {
+    "stage": 1
+  }
+}

data/data_insight_sft.sample.jsonl

@@ -0,0 +1 @@
+{"system":"You are a data insight specialist. Extract only supported facts, insight candidates, evidence references, and uncertainty.","prompt":"Business goal: explain why East China hotel room nights declined last week.\nTable snippet:\nregion,last_week,week_before,conversion_rate,avg_selling_price\nEast China,12430,13820,3.1%,418\nSouth China,15890,16020,3.7%,421\nLast week East China conversion rate was 3.1%; the week before it was 3.8%.\nReturn strict JSON with keys facts, insights, evidence_refs, uncertainties.","response":"{\"facts\":[\"East China room nights fell from 13,820 to 12,430 week over week.\",\"East China conversion rate dropped from 3.8% to 3.1%.\",\"Average selling price in East China was 418, close to South China at 421.\"],\"insights\":[\"The decline is consistent with weaker conversion, not an obvious pricing change.\"],\"evidence_refs\":[\"row:East China\",\"metric:conversion_rate\",\"metric:avg_selling_price\"],\"uncertainties\":[\"No traffic or channel mix data is provided, so root-cause attribution remains incomplete.\"]}"}

data/writer_preference.sample.jsonl

@@ -0,0 +1 @@
+{"system":"You are a business analysis writer. Use only supplied evidence and prefer reliable, evidence-grounded conclusions.","prompt":"Question: explain whether pricing caused the East China decline.\nEvidence:\n- East China room nights fell from 13,820 to 12,430 week over week.\n- Conversion rate dropped from 3.8% to 3.1%.\n- Average selling price stayed flat at 418.\nChoose the better answer for reliability.","chosen":"Pricing is not supported as the main cause from the current evidence. The stronger supported signal is a conversion decline, while traffic and channel data are still missing for a fuller diagnosis.","rejected":"The decline was clearly caused by aggressive price increases in East China, so the team should immediately cut price to recover demand."}

data/writer_prompts.sample.jsonl

@@ -0,0 +1 @@
+{"system":"You are a business analysis writer. Use only supplied evidence and keep unsupported claims out of the answer.","prompt":"Prepare a concise chatbot answer for an executive asking why East China room nights declined last week. Mention only what the evidence supports."}

data/writer_sft.sample.jsonl

@@ -0,0 +1 @@
+{"system":"You are a business analysis writer. Use only supplied evidence. Separate facts from hypotheses when support is incomplete.","prompt":"Write a short executive brief using only the evidence below.\nEvidence:\n- East China room nights fell from 13,820 to 12,430 week over week.\n- Conversion rate dropped from 3.8% to 3.1%.\n- Average selling price stayed broadly flat at 418.\nRequirements:\n1. Keep to 3 bullets.\n2. Cite uncertainty explicitly.\n3. Do not claim a cause without support.","response":"- East China room nights declined 10.1% week over week, and the clearest supported change in the funnel is a conversion drop from 3.8% to 3.1%.\n- Pricing does not appear to be the primary driver from the available evidence because average selling price remained broadly flat at 418.\n- Additional traffic and channel-mix data is still needed before making a stronger causal conclusion."}

data_adapter.py

@@ -0,0 +1,384 @@
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Iterable, Optional, Tuple
+
+from datasets import Dataset, DatasetDict, load_dataset, load_from_disk
+
+from utils import SYSTEM_PROMPT
+
+
+_LOCAL_DATASET_LOADERS = {
+    ".json": "json",
+    ".jsonl": "json",
+    ".csv": "csv",
+    ".parquet": "parquet",
+}
+
+
+def load_sft_dataset(
+    dataset_name: str,
+    dataset_sub_name: str = "",
+    split: str = "train",
+    default_system_prompt: str = SYSTEM_PROMPT,
+) -> Dataset:
+    dataset = load_dataset_split(dataset_name, dataset_sub_name=dataset_sub_name, split=split)
+    return dataset.map(
+        lambda example: normalize_sft_example(example, default_system_prompt=default_system_prompt),
+        remove_columns=dataset.column_names,
+    )
+
+
+def load_preference_dataset(
+    dataset_name: str,
+    dataset_sub_name: str = "",
+    split: str = "train",
+    default_system_prompt: str = SYSTEM_PROMPT,
+) -> Dataset:
+    dataset = load_dataset_split(dataset_name, dataset_sub_name=dataset_sub_name, split=split)
+    return dataset.map(
+        lambda example: normalize_preference_example(example, default_system_prompt=default_system_prompt),
+        remove_columns=dataset.column_names,
+    )
+
+
+def load_prompt_dataset(
+    dataset_name: str,
+    dataset_sub_name: str = "",
+    split: str = "train",
+    default_system_prompt: str = SYSTEM_PROMPT,
+) -> Dataset:
+    dataset = load_dataset_split(dataset_name, dataset_sub_name=dataset_sub_name, split=split)
+    return dataset.map(
+        lambda example: normalize_prompt_example(example, default_system_prompt=default_system_prompt),
+        remove_columns=dataset.column_names,
+    )
+
+
+def load_dataset_split(dataset_name: str, dataset_sub_name: str = "", split: str = "train") -> Dataset:
+    expanded_name = os.path.expanduser(dataset_name)
+    if os.path.exists(expanded_name):
+        dataset = _load_local_dataset(Path(expanded_name), split=split)
+        return _select_split(dataset, split)
+
+    if dataset_sub_name:
+        return load_dataset(dataset_name, dataset_sub_name, split=split)
+    return load_dataset(dataset_name, split=split)
+
+
+def normalize_sft_example(example: Dict[str, Any], default_system_prompt: str = SYSTEM_PROMPT) -> Dict[str, str]:
+    if "messages" in example or "conversations" in example:
+        messages = _coerce_messages(example.get("messages", example.get("conversations")))
+        if messages:
+            system_prompt, prompt, response = _messages_to_sft_fields(messages, default_system_prompt)
+            return {
+                "system": system_prompt,
+                "prompt": prompt,
+                "response": response,
+            }
+
+    prompt = _get_first_value(example, ("prompt", "question"))
+    response = _get_first_value(example, ("response", "answer", "output", "completion"))
+
+    if prompt is None and "instruction" in example and "output" in example:
+        prompt = " ".join(
+            part for part in (_stringify_text(example["instruction"]), _stringify_text(example.get("input"))) if part
+        )
+        response = _stringify_text(example["output"])
+
+    if prompt is None or response is None:
+        raise ValueError(
+            "Unsupported SFT dataset schema. Expected prompt/response, question/answer, instruction/output, "
+            f"or messages. Found columns: {sorted(example.keys())}"
+        )
+
+    return {
+        "system": _extract_system_prompt(example, default_system_prompt),
+        "prompt": _stringify_text(prompt),
+        "response": _stringify_text(response),
+    }
+
+
+def normalize_preference_example(
+    example: Dict[str, Any],
+    default_system_prompt: str = SYSTEM_PROMPT,
+) -> Dict[str, str]:
+    if {"chosen", "rejected"}.issubset(example.keys()) and "prompt" not in example and "question" not in example:
+        system_prompt, prompt, chosen = _extract_hh_prompt_and_response(
+            _stringify_text(example["chosen"]),
+            default_system_prompt=default_system_prompt,
+        )
+        _, rejected_prompt, rejected = _extract_hh_prompt_and_response(
+            _stringify_text(example["rejected"]),
+            default_system_prompt=default_system_prompt,
+        )
+        prompt = prompt or rejected_prompt
+        return {
+            "system": system_prompt,
+            "prompt": prompt,
+            "chosen": chosen,
+            "rejected": rejected,
+        }
+
+    if {
+        "prompt",
+        "response_0",
+        "response_1",
+        "better_response_id",
+    }.issubset(example.keys()):
+        chosen, rejected = _select_pairwise_responses(example)
+        return {
+            "system": _extract_system_prompt(example, default_system_prompt),
+            "prompt": _stringify_text(example["prompt"]),
+            "chosen": chosen,
+            "rejected": rejected,
+        }
+
+    prompt = _get_first_value(example, ("prompt", "question"))
+    chosen = _get_first_value(example, ("chosen", "response_chosen", "preferred"))
+    rejected = _get_first_value(example, ("rejected", "response_rejected", "dispreferred"))
+
+    if prompt is None or chosen is None or rejected is None:
+        raise ValueError(
+            "Unsupported preference dataset schema. Expected prompt/chosen/rejected, "
+            "question/response_chosen/response_rejected, SafeRLHF columns, or HH-RLHF chosen/rejected. "
+            f"Found columns: {sorted(example.keys())}"
+        )
+
+    return {
+        "system": _extract_system_prompt(example, default_system_prompt),
+        "prompt": _stringify_text(prompt),
+        "chosen": _stringify_text(chosen),
+        "rejected": _stringify_text(rejected),
+    }
+
+
+def normalize_prompt_example(example: Dict[str, Any], default_system_prompt: str = SYSTEM_PROMPT) -> Dict[str, str]:
+    if "messages" in example or "conversations" in example:
+        messages = _coerce_messages(example.get("messages", example.get("conversations")))
+        if messages:
+            system_prompt, prompt, _ = _messages_to_sft_fields(messages, default_system_prompt)
+            return {
+                "system": system_prompt,
+                "prompt": prompt,
+            }
+
+    if {
+        "chosen",
+        "rejected",
+    }.issubset(example.keys()) and "prompt" not in example and "question" not in example:
+        system_prompt, prompt, _ = _extract_hh_prompt_and_response(
+            _stringify_text(example["chosen"]),
+            default_system_prompt=default_system_prompt,
+        )
+        return {
+            "system": system_prompt,
+            "prompt": prompt,
+        }
+
+    prompt = _get_first_value(example, ("prompt", "question"))
+    if prompt is None and "instruction" in example:
+        prompt = " ".join(
+            part for part in (_stringify_text(example["instruction"]), _stringify_text(example.get("input"))) if part
+        )
+
+    if prompt is None:
+        raise ValueError(
+            "Unsupported prompt dataset schema. Expected prompt/question/instruction, messages, or HH-RLHF chosen. "
+            f"Found columns: {sorted(example.keys())}"
+        )
+
+    return {
+        "system": _extract_system_prompt(example, default_system_prompt),
+        "prompt": _stringify_text(prompt),
+    }
+
+
+def _load_local_dataset(dataset_path: Path, split: str):
+    if dataset_path.is_file():
+        loader_name = _loader_name_from_suffix(dataset_path.suffix)
+        return load_dataset(loader_name, data_files={split: str(dataset_path)})
+
+    try:
+        return load_from_disk(str(dataset_path))
+    except (FileNotFoundError, ValueError):
+        data_file = _discover_local_data_file(dataset_path, split=split)
+        loader_name = _loader_name_from_suffix(data_file.suffix)
+        return load_dataset(loader_name, data_files={split: str(data_file)})
+
+
+def _select_split(dataset, split: str) -> Dataset:
+    if isinstance(dataset, DatasetDict):
+        if split in dataset:
+            return dataset[split]
+        first_split = next(iter(dataset.keys()))
+        return dataset[first_split]
+    return dataset
+
+
+def _discover_local_data_file(dataset_dir: Path, split: str) -> Path:
+    for suffix in _LOCAL_DATASET_LOADERS:
+        candidate = dataset_dir / f"{split}{suffix}"
+        if candidate.exists():
+            return candidate
+
+    candidates = []
+    for suffix in _LOCAL_DATASET_LOADERS:
+        candidates.extend(sorted(dataset_dir.glob(f"*{suffix}")))
+
+    if len(candidates) == 1:
+        return candidates[0]
+
+    raise ValueError(
+        f"Could not infer dataset file under {dataset_dir}. "
+        f"Expected {split}.jsonl/.json/.csv/.parquet or exactly one supported file."
+    )
+
+
+def _loader_name_from_suffix(suffix: str) -> str:
+    if suffix not in _LOCAL_DATASET_LOADERS:
+        raise ValueError(f"Unsupported local dataset format: {suffix}")
+    return _LOCAL_DATASET_LOADERS[suffix]
+
+
+def _extract_system_prompt(example: Dict[str, Any], default_system_prompt: str) -> str:
+    system_prompt = _get_first_value(example, ("system", "system_prompt", "system_message"))
+    system_prompt = _stringify_text(system_prompt)
+    return system_prompt or default_system_prompt
+
+
+def _get_first_value(example: Dict[str, Any], keys: Iterable[str]):
+    for key in keys:
+        if key in example and example[key] is not None:
+            return example[key]
+    return None
+
+
+def _stringify_text(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, list):
+        parts = [_stringify_text(item) for item in value]
+        return "\n".join(part for part in parts if part).strip()
+    if isinstance(value, dict):
+        text_value = value.get("text")
+        if text_value is not None:
+            return _stringify_text(text_value)
+        content_value = value.get("content")
+        if content_value is not None:
+            return _stringify_text(content_value)
+        return json.dumps(value, ensure_ascii=False, sort_keys=True)
+    return str(value).strip()
+
+
+def _coerce_messages(raw_messages: Any):
+    if raw_messages is None:
+        return None
+    if isinstance(raw_messages, str):
+        raw_messages = json.loads(raw_messages)
+    if not isinstance(raw_messages, list):
+        raise ValueError(f"Unsupported messages payload: {type(raw_messages)}")
+    return raw_messages
+
+
+def _messages_to_sft_fields(messages, default_system_prompt: str) -> Tuple[str, str, str]:
+    if not messages:
+        raise ValueError("Empty messages payload.")
+
+    assistant_indexes = [
+        index for index, message in enumerate(messages) if _normalize_role(message.get("role", message.get("from"))) == "assistant"
+    ]
+    if not assistant_indexes:
+        raise ValueError("messages must contain at least one assistant turn.")
+
+    final_assistant_index = assistant_indexes[-1]
+    system_parts = []
+    prompt_lines = []
+    response = ""
+
+    for index, message in enumerate(messages):
+        role = _normalize_role(message.get("role", message.get("from", message.get("speaker"))))
+        content = _stringify_text(message.get("content", message.get("value", message.get("text"))))
+        if not content:
+            continue
+        if role == "system":
+            system_parts.append(content)
+            continue
+        if index == final_assistant_index:
+            response = content
+            continue
+        prompt_lines.append(f"{_render_role(role)}: {content}")
+
+    if not response:
+        raise ValueError("The final assistant turn is empty.")
+
+    system_prompt = "\n".join(system_parts).strip() or default_system_prompt
+    prompt = "\n".join(prompt_lines).strip()
+    return system_prompt, prompt, response
+
+
+def _normalize_role(role: Optional[str]) -> str:
+    normalized_role = (role or "").strip().lower()
+    role_map = {
+        "human": "user",
+        "user": "user",
+        "assistant": "assistant",
+        "gpt": "assistant",
+        "bot": "assistant",
+        "system": "system",
+        "tool": "tool",
+        "function": "tool",
+    }
+    return role_map.get(normalized_role, normalized_role or "user")
+
+
+def _render_role(role: str) -> str:
+    label_map = {
+        "user": "User",
+        "assistant": "Assistant",
+        "tool": "Tool",
+    }
+    return label_map.get(role, role.title())
+
+
+def _extract_hh_prompt_and_response(text: str, default_system_prompt: str) -> Tuple[str, str, str]:
+    cleaned_text = text.lstrip()
+    chunks = re.split(r"\n\nAssistant:", cleaned_text)
+    if len(chunks) < 2:
+        raise ValueError("Invalid HH-RLHF transcript: missing assistant response.")
+
+    prompt_part = "\n\nAssistant:".join(chunks[:-1]).strip()
+    response = chunks[-1].strip()
+    prompt_lines = []
+    for block in re.split(r"\n\n", prompt_part):
+        current_block = block.strip()
+        if current_block.startswith("Human:"):
+            prompt_lines.append(f"User: {current_block[len('Human:'):].strip()}")
+        elif current_block.startswith("Assistant:"):
+            prompt_lines.append(f"Assistant: {current_block[len('Assistant:'):].strip()}")
+
+    return default_system_prompt, "\n".join(prompt_lines).strip(), response
+
+
+def _select_pairwise_responses(example: Dict[str, Any]) -> Tuple[str, str]:
+    response_0 = _stringify_text(example["response_0"])
+    response_1 = _stringify_text(example["response_1"])
+    better_id = int(example["better_response_id"])
+
+    if {
+        "is_response_0_safe",
+        "is_response_1_safe",
+    }.issubset(example.keys()):
+        response_0_safe = bool(example["is_response_0_safe"])
+        response_1_safe = bool(example["is_response_1_safe"])
+        if response_0_safe and not response_1_safe:
+            return response_0, response_1
+        if response_1_safe and not response_0_safe:
+            return response_1, response_0
+
+    if better_id == 0:
+        return response_0, response_1
+    return response_1, response_0

dpo.py

@@ -0,0 +1,142 @@
+import os
+from trl import DPOTrainer, DPOConfig
+import torch
+from accelerate import Accelerator
+from utils import (
+    ScriptArguments,
+    DEFINE_PAD_TOKEN,
+    create_peft,
+    format_prompt,
+    resolve_system_prompt,
+)
+from transformers import (
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    HfArgumentParser,
+    AutoModelForCausalLM,
+)
+from data_adapter import load_preference_dataset
+
+os.environ["WANDB_PROJECT"] = "ma-rlhf"
+os.environ["WANDB_RUN_NAME"] = "dpo"
+
+parser = HfArgumentParser(ScriptArguments)
+train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+
+dataset_name = train_args.dataset_name
+dataset_sub_name = train_args.dataset_sub_name
+dataset_split = train_args.dataset_split
+model_name = train_args.model_name
+deepspeed_config_name = train_args.deepspeed_config_name
+output_max_length = train_args.output_max_length
+seq_length = train_args.seq_length
+batch_size = train_args.batch_size
+output_name = train_args.output_name
+is_peft = train_args.use_QLora
+is_use_flash_attention2 = train_args.use_flash_attention_2
+num_train_epochs = train_args.num_train_epochs
+beta = 0.1 # default
+gradient_accumulation_steps = train_args.gradient_accumulation_steps
+learning_rate = train_args.learning_rate
+use_qlora_double_quant = train_args.use_qlora_double_quant
+default_system_prompt = resolve_system_prompt(train_args.system_prompt)
+
+
+def create_model_tokenizer(name):
+    # QLoRA
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=use_qlora_double_quant,
+    )
+
+    device_map = {"": Accelerator().local_process_index}
+    print('device map: ', device_map)
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        quantization_config=bnb_config if is_peft else None,
+        device_map=device_map,
+        trust_remote_code=True,
+        use_flash_attention_2=is_use_flash_attention2,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True, model_max_length=seq_length,
+        trust_remote_code=True,)
+
+    tokenizer.add_special_tokens({'pad_token': DEFINE_PAD_TOKEN})
+    model.pad_token_id = tokenizer.pad_token_id
+    model.pad_token = tokenizer.pad_token
+
+
+    return model, tokenizer
+
+
+def create_dpo_datasets(datasets_name, dataset_sub_name, tokenizer):
+    train_dataset = load_preference_dataset(
+        datasets_name,
+        dataset_sub_name=dataset_sub_name,
+        split=dataset_split,
+        default_system_prompt=default_system_prompt,
+    )
+    train_dataset = train_dataset.map(
+        lambda example: {
+            "prompt": format_prompt(example["prompt"], system_prompt=example["system"]),
+            "chosen": example["chosen"],
+            "rejected": example["rejected"],
+        },
+        remove_columns=["system"],
+    )
+
+    return train_dataset, None
+
+
+def train():
+    model, tokenizer = create_model_tokenizer(model_name)  # model is sequence classification
+    train_datasets, test_datasets = create_dpo_datasets(
+        dataset_name, None, tokenizer
+    )
+
+    # PEFT
+    peft_config = create_peft(is_peft)
+
+    training_args = DPOConfig(
+        output_dir=output_name,
+        save_strategy='epoch',
+        logging_steps=1,
+        num_train_epochs=num_train_epochs,
+        gradient_checkpointing=True,
+        bf16=True,
+        learning_rate=learning_rate,
+        warmup_ratio=0.05,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        gradient_accumulation_steps=gradient_accumulation_steps,
+        deepspeed=deepspeed_config_name,
+        report_to='wandb',
+        lr_scheduler_type='cosine',
+        # max_steps=100,
+        # loss_type: Literal[
+        #     "sigmoid", "hinge", "ipo", "kto_pair", "bco_pair", "sppo_hard", "nca_pair", "robust"
+        # ] = "sigmoid"
+        loss_type='sigmoid', # standard dpo
+        dataset_num_proc=64,
+        max_completion_length=output_max_length,
+        max_prompt_length= output_max_length,
+        max_length=seq_length,
+        )
+
+    trainer = DPOTrainer(
+        model,
+        None,
+        args=training_args,
+        train_dataset=train_datasets,
+        peft_config=peft_config,
+        processing_class=tokenizer,
+    )
+
+    trainer.train()
+    trainer.save_model(output_name)
+
+
+if __name__ == "__main__":
+    train()

ma_ppo_config.py

@@ -0,0 +1,239 @@
+# 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 MultiAdapterPPOConfig:
+    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"] = "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
+    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"]
+
+    def to_dict(self):
+        output_dict = {}
+        for key, value in self.__dict__.items():
+            output_dict[key] = value
+        return flatten_dict(output_dict)

ma_ppo_trainer.py

@@ -0,0 +1,1654 @@
+# 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 os
+import time
+import typing
+import warnings
+from contextlib import nullcontext
+from typing import Callable, List, Optional, Union, Dict
+import random
+
+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,
+    is_torch_npu_available,
+    is_torch_xpu_available,
+)
+from huggingface_hub import PyTorchModelHubMixin
+
+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,
+)
+WANDB_PADDING = -1
+
+from trl.trainer.utils import RunningMoments
+from torch.nn.utils.rnn import pad_sequence
+
+# from trl.import_utils import is_torch_greater_2_0
+from trl.models import (
+    SUPPORTED_ARCHITECTURES,
+    PreTrainedModelWrapper,
+    create_reference_model,
+    unwrap_model_for_generation,
+)
+# from trl import BaseTrainer
+from ma_ppo_config import MultiAdapterPPOConfig
+
+
+if is_deepspeed_available():
+    import deepspeed
+
+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"])
+```
+"""
+
+class BaseTrainer(PyTorchModelHubMixin):
+    r"""
+    Base class for all trainers - this base class implements the basic functions that we
+    need for a trainer.
+
+    The trainer needs to have the following functions:
+        - step: takes in a batch of data and performs a step of training
+        - loss: takes in a batch of data and returns the loss
+        - compute_rewards: takes in a batch of data and returns the rewards
+        - _build_models_and_tokenizer: builds the models and tokenizer
+        - _build_dataset: builds the dataset
+    Each user is expected to implement their own trainer class that inherits from this base
+    if they want to use a new training algorithm.
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+    def step(self, *args):
+        raise NotImplementedError("Not implemented")
+
+    def loss(self, *args):
+        raise NotImplementedError("Not implemented")
+
+    def compute_rewards(self, *args):
+        raise NotImplementedError("Not implemented")
+
+    def _save_pretrained(self, save_directory):
+        raise NotImplementedError("Not implemented")
+
+
+class AdaptiveKLController:
+    """
+    Adaptive KL controller described in the paper:
+    https://huggingface.co/papers/1909.08593
+    """
+
+    def __init__(self, init_kl_coef, target, horizon):
+        self.value = init_kl_coef
+        self.target = target
+        self.horizon = horizon
+
+    def update(self, current, n_steps):
+        target = self.target
+        proportional_error = np.clip(current / target - 1, -0.2, 0.2)
+        mult = 1 + proportional_error * n_steps / self.horizon
+        self.value *= mult
+
+
+class FixedKLController:
+    """Fixed KL controller."""
+
+    def __init__(self, kl_coef):
+        self.value = kl_coef
+
+    def update(self, current, n_steps):
+        pass
+
+
+
+def is_torch_greater_2_0() -> bool:
+    if _is_python_greater_3_8:
+        from importlib.metadata import version
+
+        torch_version = version("torch")
+    else:
+        import pkg_resources
+
+        torch_version = pkg_resources.get_distribution("torch").version
+    return torch_version >= "2.0"
+
+
+def clip_by_value(x: torch.Tensor, tensor_min: float, tensor_max: float) -> torch.Tensor:
+    """
+    Tensor extension to torch.clamp
+    https://github.com/pytorch/pytorch/issues/2793#issuecomment-428784713
+    """
+    clipped = torch.max(torch.min(x, tensor_max), tensor_min)
+    return clipped
+
+def convert_to_scalar(stats: Dict) -> Dict:
+    """
+    Converts the stats from a flattened dict to single scalar dicts
+    """
+    tensorboard_stats = {}
+    for k, v in stats.items():
+        # for tensorboard compatibility - arrays and tensors are ignored with tensorboard
+        # therefore we convert single element tensors to scalars
+        if (isinstance(v, torch.Tensor) or isinstance(v, np.ndarray)) and (
+            len(v.shape) == 0 or (len(v.shape) == 1 and v.shape[0] == 1)
+        ):
+            v = v.item()
+        tensorboard_stats[k] = v
+    return tensorboard_stats
+
+
+def entropy_from_logits(logits: torch.Tensor) -> torch.Tensor:
+    """Calculate entropy from logits."""
+    pd = torch.nn.functional.softmax(logits, dim=-1)
+    entropy = torch.logsumexp(logits, axis=-1) - torch.sum(pd * logits, axis=-1)
+    return entropy
+
+
+def logprobs_from_logits(logits: torch.Tensor, labels: torch.Tensor, gather: bool = True) -> torch.Tensor:
+    """
+    See: https://github.com/pytorch/pytorch/issues/563#issuecomment-330103591
+    """
+    logp = F.log_softmax(logits, dim=2)
+
+    if not gather:
+        return logp
+    logpy = torch.gather(logp, 2, labels.unsqueeze(2)).squeeze(-1)
+    return logpy
+
+
+def stack_dicts(stats_dicts: List[Dict]) -> Dict:
+    """Stack the values of a dict."""
+    results = dict()
+    for k in stats_dicts[0]:
+        stats_list = [torch.flatten(d[k]) for d in stats_dicts]
+        results[k] = pad_sequence(stats_list, batch_first=True, padding_value=WANDB_PADDING)
+    return results
+
+def stats_to_np(stats_dict: Dict) -> Dict:
+    """Cast all torch.tensors in dict to numpy arrays."""
+    new_dict = dict()
+    for k, v in stats_dict.items():
+        if isinstance(v, torch.Tensor):
+            new_dict[k] = v.detach().cpu()
+            if new_dict[k].dtype == torch.bfloat16:
+                new_dict[k] = new_dict[k].float()
+            new_dict[k] = new_dict[k].numpy()
+        else:
+            new_dict[k] = v
+        if np.isscalar(new_dict[k]):
+            new_dict[k] = float(new_dict[k])
+    return new_dict
+
+
+def set_seed(seed: int) -> None:
+    """
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, and `torch`.
+
+    Args:
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if is_torch_xpu_available():
+        torch.xpu.manual_seed_all(seed)
+    elif is_torch_npu_available():
+        torch.npu.manual_seed_all(seed)
+    else:
+        torch.cuda.manual_seed_all(seed)
+
+
+
+class MultiAdapterPPOTrainer(BaseTrainer):
+    """
+    The MultiAdapterPPOTrainer 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 MultiAdapterPPOTrainer. 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,
+        config: Optional[MultiAdapterPPOConfig] = 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,
+    ):
+        """
+        Initialize MultiAdapterPPOTrainer.
+
+        Args:
+            config (`PPOConfig`):
+                Configuration object for MultiAdapterPPOTrainer. 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(
+            "`MultiAdapterPPOTrainer` 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)
+
+        # Step 0: check positional arguments validity
+        if not isinstance(config, MultiAdapterPPOConfig):
+            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,
+        )
+
+        # 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 `MultiAdapterPPOTrainer`. 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"
+        )
+
+        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)
+
+        (
+            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,
+        )
+        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._prepare_deepspeed(self.ref_model)
+        else:
+            self.ref_model = self.accelerator.prepare(self.ref_model)
+
+        # 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 _ 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,
+                        )
+                        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)
+
+            # 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
+
+        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
+        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:
+            self.lr_scheduler.step()
+
+        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)
+
+        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
+        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 _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

merge_adapter.py

@@ -0,0 +1,47 @@
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+import torch
+from utils import ScriptArguments
+
+parser = HfArgumentParser(ScriptArguments)
+train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+
+base_model_name = train_args.base_model_name
+model_name = train_args.model_name
+merged_model_name = train_args.merged_model_name
+
+
+def merge(model_base_name, model_adapter_name, model_merge_name):
+    # use cpu avoid gpu vram OOM
+    # if cpu memory small, use swap
+    model = AutoModelForCausalLM.from_pretrained(
+        model_base_name, device_map='auto', torch_dtype=torch.bfloat16, trust_remote_code=True, # llama-7b base
+    )
+    print('load base model')
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_adapter_name,
+        trust_remote_code=True,
+    )
+
+    model = PeftModel.from_pretrained(
+        model,
+        model_adapter_name,  # adapter
+        device_map='auto',
+        trust_remote_code=True,
+    )
+    # print(model)
+    print('load lora')
+
+    model = model.merge_and_unload()
+    print('merge base model + lora model finish')
+    # print(model)
+
+    model.save_pretrained(model_merge_name)
+    tokenizer.save_pretrained(model_merge_name)
+    print('save model finish')
+
+
+if __name__ == "__main__":
+    merge(base_model_name, model_name, merged_model_name)
+    print('------merge done!---------')

ppo_multi_adapter.py

@@ -0,0 +1,221 @@
+'''
+this code required trl==0.11.0 and support multi-adapter LoRA training
+'''
+
+from codecs import BOM_BE
+import re
+import torch
+import os
+from trl import AutoModelForCausalLMWithValueHead, PPOTrainer, PPOConfig
+from trl.core import LengthSampler
+from transformers import AutoTokenizer, BitsAndBytesConfig, HfArgumentParser
+from accelerate import Accelerator
+from utils import (
+    create_model_tokenizer,
+    create_peft,
+    is_main_process,
+    ScriptArguments,
+    DEFINE_EOS_TOKEN,
+    DEFINE_PAD_TOKEN,
+    format_prompt,
+    resolve_system_prompt,
+)
+import time
+from ma_ppo_config import MultiAdapterPPOConfig
+from ma_ppo_trainer import MultiAdapterPPOTrainer
+from data_adapter import load_prompt_dataset
+
+os.environ["WANDB_PROJECT"] = "ma-rlhf"
+os.environ["WANDB_RUN_NAME"] = "ppo"
+
+
+# class MyPPOTrainer(PPOTrainer):
+parser = HfArgumentParser(ScriptArguments)
+train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+
+dataset_name = train_args.dataset_name
+dataset_sub_name = train_args.dataset_sub_name
+dataset_split = train_args.dataset_split
+model_name = train_args.model_name
+rm_model_name = train_args.reward_model_name
+deepspeed_config_name = train_args.deepspeed_config_name
+batch_size = train_args.batch_size
+mini_batch_size = train_args.mini_batch_size
+ppo_epochs = train_args.ppo_epochs
+output_max_length = train_args.output_max_length
+seq_length = train_args.seq_length
+output_name = train_args.output_name
+is_peft = train_args.use_QLora
+is_use_flash_attention2 = train_args.use_flash_attention_2
+
+gradient_accumulation_steps = train_args.gradient_accumulation_steps
+default_system_prompt = resolve_system_prompt(train_args.system_prompt)
+
+def create_model_tokenizer(name, rm_model_name, peft_config):
+    # QLoRA
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16,
+        # bnb_4bit_use_double_quant=True,
+    )
+
+    device_map = {"": Accelerator().local_process_index}
+    print('device map: ', device_map)
+
+    model = AutoModelForCausalLMWithValueHead.from_pretrained(
+        name,
+        quantization_config=bnb_config,
+        peft_config=peft_config,
+        reward_adapter=rm_model_name,
+        device_map=device_map,  # 70b use 'auto' would auto shard parameter
+        use_flash_attention_2=is_use_flash_attention2,
+        trust_remote_code=True,
+        # low_cpu_mem_usage=True,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_name,
+        # use_fast=True,
+        trust_remote_code=True,
+    )
+    tokenizer.add_special_tokens({'pad_token': DEFINE_PAD_TOKEN})
+    model.pad_token_id = tokenizer.pad_token_id
+    model.pad_token = tokenizer.pad_token
+    model.pad_token_id = tokenizer.pad_token_id
+    # model.config.pad_token_id = model.config.eos_token_id
+
+    return model, tokenizer
+
+
+def create_dataset(dataset_name, tokenizer):
+    datasets = load_prompt_dataset(
+        dataset_name,
+        dataset_sub_name=dataset_sub_name,
+        split=dataset_split,
+        default_system_prompt=default_system_prompt,
+    )
+    datasets = datasets.map(
+        lambda examples: {
+            "query": [
+                format_prompt(question, system_prompt=system_prompt)
+                for system_prompt, question in zip(examples["system"], examples["prompt"])
+            ],
+            "input_ids": [
+                tokenizer(
+                    format_prompt(question, system_prompt=system_prompt),
+                    return_tensors="pt",
+                )["input_ids"][0]
+                for system_prompt, question in zip(examples["system"], examples["prompt"])
+            ],
+        },
+        batched=True,
+        remove_columns=datasets.column_names,
+    )
+
+    datasets = datasets.filter(lambda x: len(x["input_ids"]) < seq_length, batched=False)
+    datasets.set_format(type="torch")
+    return datasets
+
+
+def collator(examples):
+    batch = {'query': [], 'input_ids': []}
+    for example in examples:
+        batch['query'].append(example['query'])
+        batch['input_ids'].append(torch.tensor(example['input_ids'], dtype=torch.long))
+    return batch
+
+def train():
+    peft_config = create_peft(is_peft)
+    model, tokenizer = create_model_tokenizer(
+        model_name, rm_model_name, peft_config
+    )  # model is sequence classification
+
+    dataset = create_dataset(dataset_name, tokenizer)
+    print(dataset)
+
+    # generation config
+    generation_kwargs = {
+        "min_length": -1,
+        "max_new_tokens": output_max_length,
+        "top_k": 0.0,
+        "top_p": 1.0,
+        "do_sample": True,
+        "pad_token_id": tokenizer.pad_token_id,
+        "eos_token_id": tokenizer.eos_token_id,
+        "forced_eos_token_id": tokenizer.eos_token_id, # class ForcedEOSTokenLogitsProcessor(LogitsProcessor) from transformers
+        # "forced_eos_token_id": True,
+    }
+    output_length_sampler = LengthSampler(128, output_max_length)
+
+    config = MultiAdapterPPOConfig(
+        log_with='wandb',
+        learning_rate=1e-5,
+        batch_size=batch_size,
+        mini_batch_size=mini_batch_size,
+        gradient_accumulation_steps=gradient_accumulation_steps,
+        optimize_cuda_cache=True,
+        early_stopping=True,
+        target_kl=0.1,
+        ppo_epochs=ppo_epochs,
+        seed=0,
+        init_kl_coef=0.2,
+        adap_kl_ctrl=True,
+        max_grad_norm=1.0,  # fix generate nan
+    )
+
+    trainer = MultiAdapterPPOTrainer(
+        config,
+        model,
+        ref_model=None,  # share parameters
+        tokenizer=tokenizer,
+        dataset=dataset,
+        data_collator=collator,
+    )
+
+    reward_baseline = 0.0
+    save_freq = 50
+
+    # for epoch, batch in enumerate(trainer.dataloader):
+    for epoch, batch in enumerate(trainer.dataloader):
+        start_time = time.time()
+
+        if epoch >= config.total_ppo_epochs:
+            break
+
+        question_tensors = batch["input_ids"]
+        response_tensors = trainer.generate(
+            question_tensors,
+            return_prompt=False,
+            # length_sampler=output_length_sampler,
+            **generation_kwargs,
+        )
+        batch["response"] = tokenizer.batch_decode(response_tensors, skip_special_tokens=True)
+
+        texts = [q + r for q, r in zip(batch["query"], batch["response"])]
+        rm_model = trainer.accelerator.unwrap_model(trainer.model)
+        raw_rewards = []
+        for text in texts:
+            inputs = tokenizer(text, return_tensors='pt').to(trainer.accelerator.device)
+            score = rm_model.compute_reward_score(**inputs)[0,-1,0] - reward_baseline
+            raw_rewards.append(score)
+        rewards = raw_rewards
+
+        ## PPO Step
+        stats = trainer.step(question_tensors, response_tensors, rewards)
+        trainer.log_stats(stats, batch, rewards)
+
+        if is_main_process():
+            for text, reward in zip(texts, rewards):
+                print('-----------------------------------')
+                print(text)
+                print(reward.item())
+                print('-----------------------------------')
+            print(f"step:{epoch}/all:{len(trainer.dataloader)},loss:{stats['ppo/loss/total']},mean_scores:{stats['ppo/mean_scores']}" )
+
+        if save_freq and epoch and epoch % save_freq == 0:
+            trainer.save_pretrained(f'{output_name}_{epoch}')
+            print(f'{output_name}_{epoch}')
+            # break
+    trainer.save_pretrained(output_name)
+
+if __name__ == "__main__":
+    train()

reward_model.py

@@ -0,0 +1,176 @@
+import os
+import deepspeed
+from trl import RewardTrainer, RewardConfig
+import torch
+from accelerate import Accelerator
+from utils import (
+    ScriptArguments,
+    DEFINE_PAD_TOKEN,
+    format_prompt_answer,
+    maybe_distributed_barrier,
+    resolve_system_prompt,
+)
+from transformers import (
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    HfArgumentParser,
+    AutoModelForSequenceClassification,
+)
+from data_adapter import load_preference_dataset
+os.environ["WANDB_PROJECT"] = "ma-rlhf"
+os.environ["WANDB_RUN_NAME"] = "reward_model"
+
+parser = HfArgumentParser(ScriptArguments)
+train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+
+dataset_name = train_args.dataset_name
+dataset_sub_name = train_args.dataset_sub_name
+dataset_split = train_args.dataset_split
+model_name = train_args.model_name
+deepspeed_config_name = train_args.deepspeed_config_name
+seq_length = train_args.seq_length
+batch_size = train_args.batch_size
+output_name = train_args.output_name
+is_peft = train_args.use_QLora
+is_use_flash_attention2 = train_args.use_flash_attention_2
+num_train_epochs = train_args.num_train_epochs
+gradient_accumulation_steps = train_args.gradient_accumulation_steps
+learning_rate = train_args.learning_rate
+default_system_prompt = resolve_system_prompt(train_args.system_prompt)
+
+
+def create_model_tokenizer(name):
+    # QLoRA
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+
+    device_map = {"": Accelerator().local_process_index}
+    print('device map: ', device_map)
+
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name,
+        quantization_config=bnb_config,
+        device_map=device_map, # 70b use auto
+        num_labels=1,
+        use_cache=False,
+        trust_remote_code=True,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
+
+    tokenizer.add_special_tokens({'pad_token': DEFINE_PAD_TOKEN})
+    model.pad_token_id = tokenizer.pad_token_id
+    model.pad_token = tokenizer.pad_token
+    model.config.pad_token_id = tokenizer.pad_token_id
+    model.config.pad_token = tokenizer.pad_token
+
+    return model, tokenizer
+
+
+def create_reward_model_datasets(datasets_name, dataset_sub_name, tokenizer):
+    train_dataset = load_preference_dataset(
+        datasets_name,
+        dataset_sub_name=dataset_sub_name,
+        split=dataset_split,
+        default_system_prompt=default_system_prompt,
+    )
+    train_dataset = train_dataset.map(
+        lambda examples: tokenize_reward_batch(examples, tokenizer),
+        batched=True,
+    )
+
+    maybe_distributed_barrier()
+    train_dataset = train_dataset.filter(
+        lambda x: len(x["input_ids_chosen"]) <= seq_length
+        and len(x["input_ids_rejected"]) <= seq_length
+    )
+    maybe_distributed_barrier()
+
+    # eval_dataset = eval_dataset.map(
+    #     preprocess_function_hhrlhf,
+    #     batched=True,
+    #     num_proc=8,
+    # )
+
+    # torch.distributed.barrier()
+    # eval_dataset = eval_dataset.filter(
+    #     lambda x: len(x["input_ids_chosen"]) <= seq_length
+    #     and len(x["input_ids_rejected"]) <= seq_length
+    # )
+
+    # torch.distributed.barrier()
+
+    # return train_dataset, eval_dataset
+    return train_dataset, None
+
+
+def tokenize_reward_batch(examples, tokenizer):
+    new_examples = {
+        "input_ids_chosen": [],
+        "attention_mask_chosen": [],
+        "input_ids_rejected": [],
+        "attention_mask_rejected": [],
+    }
+    for system_prompt, prompt, response_chosen, response_rejected in zip(
+        examples["system"], examples["prompt"], examples["chosen"], examples["rejected"]
+    ):
+        chosen_text = format_prompt_answer(prompt, response_chosen, system_prompt=system_prompt)
+        rejected_text = format_prompt_answer(prompt, response_rejected, system_prompt=system_prompt)
+
+        tokenized_chosen = tokenizer(chosen_text, truncation=True, padding="longest")
+        tokenized_rejected = tokenizer(rejected_text, truncation=True, padding="longest")
+
+        new_examples["input_ids_chosen"].append(tokenized_chosen["input_ids"])
+        new_examples["attention_mask_chosen"].append(tokenized_chosen["attention_mask"])
+        new_examples["input_ids_rejected"].append(tokenized_rejected["input_ids"])
+        new_examples["attention_mask_rejected"].append(tokenized_rejected["attention_mask"])
+
+    return new_examples
+
+
+def train():
+    model, tokenizer = create_model_tokenizer(model_name)  # model is sequence classification
+    train_datasets, test_datasets = create_reward_model_datasets(dataset_name, None, tokenizer)
+
+    # PEFT
+    peft_config = create_peft_reward_model(is_peft)
+
+    # ZERO stage3 use config like # https://github.com/huggingface/trl/issues/835
+    reward_config = RewardConfig(
+        output_dir=output_name,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        num_train_epochs=num_train_epochs,
+        gradient_accumulation_steps=gradient_accumulation_steps,
+        gradient_checkpointing=True,
+        learning_rate=learning_rate,
+        report_to="wandb",
+        warmup_ratio=0.01,
+        remove_unused_columns=True,
+        optim="adamw_torch",
+        logging_steps=1,
+        max_length=seq_length,
+        deepspeed=deepspeed_config_name,
+        bf16=True,
+        lr_scheduler_type='cosine',
+        # evaluation_strategy="steps",
+        # eval_steps=100,
+        # max_steps=10,
+    )
+
+    trainer = RewardTrainer(
+        model,
+        args=reward_config,
+        train_dataset=train_datasets,
+        processing_class=tokenizer,
+        peft_config=peft_config,
+    )
+
+    trainer.train()
+    trainer.save_model(output_name)
+
+
+if __name__ == "__main__":
+    train()

scripts/run_ba_role_dpo.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exp_root="$(cd "${script_dir}/.." && pwd)"
+
+role_name="${ROLE_NAME:-writer}"
+deepspeed_config_name="${DEEPSPEED_CONFIG_NAME:-${exp_root}/config/ds.json}"
+dataset_sub_name="${DATASET_SUB_NAME:-}"
+dataset_split="${DATASET_SPLIT:-train}"
+system_prompt="${SYSTEM_PROMPT:-}"
+
+output_root="${OUTPUT_ROOT:-${exp_root}/output/${role_name}}"
+model_sft_full_path="${MODEL_SFT_FULL_PATH:-${output_root}/sft_full}"
+preference_dataset_name="${PREFERENCE_DATASET_NAME:-${exp_root}/data/${role_name}_preference.jsonl}"
+model_dpo_lora_path="${output_root}/dpo_lora"
+model_dpo_full_path="${output_root}/dpo_full"
+
+mkdir -p "${output_root}"
+
+if [ ! -f "${preference_dataset_name}" ] && [ ! -d "${preference_dataset_name}" ]; then
+  echo "Missing preference dataset: ${preference_dataset_name}"
+  echo "See ${exp_root}/README.md and the sample JSONL files."
+  exit 1
+fi
+
+deepspeed "${exp_root}/dpo.py" \
+  --dataset_name="${preference_dataset_name}" \
+  --dataset_sub_name="${dataset_sub_name}" \
+  --dataset_split="${dataset_split}" \
+  --system_prompt="${system_prompt}" \
+  --model_name="${model_sft_full_path}" \
+  --output_name="${model_dpo_lora_path}" \
+  --use_QLora="${USE_QLORA:-True}" \
+  --use_flash_attention_2="${USE_FLASH_ATTENTION_2:-True}" \
+  --deepspeed_config_name="${deepspeed_config_name}" \
+  --batch_size="${BATCH_SIZE:-8}" \
+  --num_train_epochs="${NUM_TRAIN_EPOCHS:-2}" \
+  --seq_length="${SEQ_LENGTH:-1024}" \
+  --output_max_length="${OUTPUT_MAX_LENGTH:-512}" \
+  --gradient_accumulation_steps="${GRADIENT_ACCUMULATION_STEPS:-4}" \
+  --learning_rate="${LEARNING_RATE:-2e-5}"
+
+python "${exp_root}/merge_adapter.py" \
+  --base_model_name="${model_sft_full_path}" \
+  --model_name="${model_dpo_lora_path}" \
+  --merged_model_name="${model_dpo_full_path}"

scripts/run_ba_role_ppo.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exp_root="$(cd "${script_dir}/.." && pwd)"
+
+role_name="${ROLE_NAME:-writer}"
+deepspeed_config_name="${DEEPSPEED_CONFIG_NAME:-${exp_root}/config/ds.json}"
+dataset_sub_name="${DATASET_SUB_NAME:-}"
+dataset_split="${DATASET_SPLIT:-train}"
+system_prompt="${SYSTEM_PROMPT:-}"
+
+output_root="${OUTPUT_ROOT:-${exp_root}/output/${role_name}}"
+policy_model_path="${POLICY_MODEL_PATH:-${output_root}/dpo_full}"
+reward_model_name="${REWARD_MODEL_NAME:-${output_root}/reward_model_lora}"
+prompt_dataset_name="${PROMPT_DATASET_NAME:-${exp_root}/data/${role_name}_prompts.jsonl}"
+model_ppo_lora_path="${output_root}/ppo_lora"
+model_ppo_full_path="${output_root}/ppo_full"
+
+mkdir -p "${output_root}"
+
+if [ ! -f "${prompt_dataset_name}" ] && [ ! -d "${prompt_dataset_name}" ]; then
+  echo "Missing PPO prompt dataset: ${prompt_dataset_name}"
+  echo "See ${exp_root}/README.md and the sample JSONL files."
+  exit 1
+fi
+
+deepspeed "${exp_root}/ppo_multi_adapter.py" \
+  --dataset_name="${prompt_dataset_name}" \
+  --dataset_sub_name="${dataset_sub_name}" \
+  --dataset_split="${dataset_split}" \
+  --system_prompt="${system_prompt}" \
+  --model_name="${policy_model_path}" \
+  --reward_model_name="${reward_model_name}" \
+  --output_name="${model_ppo_lora_path}" \
+  --use_QLora="${USE_QLORA:-True}" \
+  --use_flash_attention_2="${USE_FLASH_ATTENTION_2:-True}" \
+  --deepspeed_config_name="${deepspeed_config_name}" \
+  --batch_size="${BATCH_SIZE:-8}" \
+  --mini_batch_size="${MINI_BATCH_SIZE:-1}" \
+  --ppo_epochs="${PPO_EPOCHS:-1}" \
+  --output_max_length="${OUTPUT_MAX_LENGTH:-512}" \
+  --seq_length="${SEQ_LENGTH:-512}" \
+  --gradient_accumulation_steps="${GRADIENT_ACCUMULATION_STEPS:-2}"
+
+python "${exp_root}/merge_adapter.py" \
+  --base_model_name="${policy_model_path}" \
+  --model_name="${model_ppo_lora_path}" \
+  --merged_model_name="${model_ppo_full_path}"

scripts/run_ba_role_reward.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exp_root="$(cd "${script_dir}/.." && pwd)"
+
+role_name="${ROLE_NAME:-writer}"
+deepspeed_config_name="${DEEPSPEED_CONFIG_NAME:-${exp_root}/config/ds.json}"
+dataset_sub_name="${DATASET_SUB_NAME:-}"
+dataset_split="${DATASET_SPLIT:-train}"
+system_prompt="${SYSTEM_PROMPT:-}"
+
+output_root="${OUTPUT_ROOT:-${exp_root}/output/${role_name}}"
+reward_base_model_path="${REWARD_BASE_MODEL_PATH:-${output_root}/sft_full}"
+preference_dataset_name="${PREFERENCE_DATASET_NAME:-${exp_root}/data/${role_name}_preference.jsonl}"
+reward_model_lora_path="${output_root}/reward_model_lora"
+
+mkdir -p "${output_root}"
+
+if [ ! -f "${preference_dataset_name}" ] && [ ! -d "${preference_dataset_name}" ]; then
+  echo "Missing preference dataset: ${preference_dataset_name}"
+  echo "See ${exp_root}/README.md and the sample JSONL files."
+  exit 1
+fi
+
+deepspeed "${exp_root}/reward_model.py" \
+  --dataset_name="${preference_dataset_name}" \
+  --dataset_sub_name="${dataset_sub_name}" \
+  --dataset_split="${dataset_split}" \
+  --system_prompt="${system_prompt}" \
+  --model_name="${reward_base_model_path}" \
+  --seq_length="${SEQ_LENGTH:-1024}" \
+  --batch_size="${BATCH_SIZE:-8}" \
+  --output_name="${reward_model_lora_path}" \
+  --use_QLora="${USE_QLORA:-True}" \
+  --use_flash_attention_2="${USE_FLASH_ATTENTION_2:-True}" \
+  --deepspeed_config_name="${deepspeed_config_name}" \
+  --num_train_epochs="${NUM_TRAIN_EPOCHS:-2}" \
+  --gradient_accumulation_steps="${GRADIENT_ACCUMULATION_STEPS:-4}" \
+  --learning_rate="${LEARNING_RATE:-2e-5}"

scripts/run_ba_role_sft.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exp_root="$(cd "${script_dir}/.." && pwd)"
+
+role_name="${ROLE_NAME:-data_insight}"
+base_model_path="${BASE_MODEL_PATH:-meta-llama/Llama-3.1-8B}"
+deepspeed_config_name="${DEEPSPEED_CONFIG_NAME:-${exp_root}/config/ds.json}"
+dataset_sub_name="${DATASET_SUB_NAME:-}"
+dataset_split="${DATASET_SPLIT:-train}"
+system_prompt="${SYSTEM_PROMPT:-}"
+
+output_root="${OUTPUT_ROOT:-${exp_root}/output/${role_name}}"
+sft_dataset_name="${SFT_DATASET_NAME:-${exp_root}/data/${role_name}_sft.jsonl}"
+model_sft_lora_path="${output_root}/sft_lora"
+model_sft_full_path="${output_root}/sft_full"
+
+mkdir -p "${output_root}"
+
+if [ ! -f "${sft_dataset_name}" ] && [ ! -d "${sft_dataset_name}" ]; then
+  echo "Missing SFT dataset: ${sft_dataset_name}"
+  echo "See ${exp_root}/README.md and the sample JSONL files."
+  exit 1
+fi
+
+deepspeed "${exp_root}/sft.py" \
+  --dataset_name="${sft_dataset_name}" \
+  --dataset_sub_name="${dataset_sub_name}" \
+  --dataset_split="${dataset_split}" \
+  --system_prompt="${system_prompt}" \
+  --model_name="${base_model_path}" \
+  --seq_length="${SEQ_LENGTH:-1024}" \
+  --output_name="${model_sft_lora_path}" \
+  --use_QLora="${USE_QLORA:-True}" \
+  --batch_size="${BATCH_SIZE:-8}" \
+  --use_flash_attention_2="${USE_FLASH_ATTENTION_2:-True}" \
+  --deepspeed_config_name="${deepspeed_config_name}" \
+  --num_train_epochs="${NUM_TRAIN_EPOCHS:-2}" \
+  --gradient_accumulation_steps="${GRADIENT_ACCUMULATION_STEPS:-8}" \
+  --learning_rate="${LEARNING_RATE:-1e-5}"
+
+python "${exp_root}/merge_adapter.py" \
+  --base_model_name="${base_model_path}" \
+  --model_name="${model_sft_lora_path}" \
+  --merged_model_name="${model_sft_full_path}"

sft.py

@@ -0,0 +1,145 @@
+import os
+import torch
+from trl import SFTTrainer, SFTConfig
+from trl.trainer.utils import DataCollatorForCompletionOnlyLM
+from accelerate import Accelerator
+import random
+random.seed(42)
+
+os.environ["WANDB_PROJECT"] = "ma-rlhf"
+os.environ["WANDB_RUN_NAME"] = "sft"
+
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    HfArgumentParser,
+)
+from utils import (
+    ScriptArguments,
+    DEFINE_PAD_TOKEN,
+    create_peft,
+    formatting_prompt_response_func_batched,
+    resolve_system_prompt,
+)
+from data_adapter import load_sft_dataset
+
+parser = HfArgumentParser(ScriptArguments)
+train_args: ScriptArguments = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+
+dataset_name = train_args.dataset_name
+dataset_sub_name = train_args.dataset_sub_name
+dataset_split = train_args.dataset_split
+model_name = train_args.model_name
+deepspeed_config_name = train_args.deepspeed_config_name
+seq_length = train_args.seq_length
+batch_size = train_args.batch_size
+output_name = train_args.output_name
+is_peft = train_args.use_QLora
+use_flash_attention_2 = train_args.use_flash_attention_2
+dataset_sub_name = None
+num_train_epochs = train_args.num_train_epochs
+gradient_accumulation_steps = train_args.gradient_accumulation_steps
+learning_rate = train_args.learning_rate
+
+default_system_prompt = resolve_system_prompt(train_args.system_prompt)
+
+
+def create_datasets(dataset_name, dataset_sub_name):
+    dataset = load_sft_dataset(
+        dataset_name,
+        dataset_sub_name=dataset_sub_name,
+        split=dataset_split,
+        default_system_prompt=default_system_prompt,
+    )
+    return dataset, None
+
+
+def create_model_tokenizer(name):
+    # QLoRA
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16
+    )
+    device_map = {"": Accelerator().local_process_index}
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        quantization_config=bnb_config if is_peft else None,
+        device_map=device_map,
+        use_flash_attention_2=use_flash_attention_2, # gpt 2 not support flash attention2
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+        use_cache=False,
+    )
+    model.gradient_checkpointing_enable()
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name,
+                                                trust_remote_code=True,
+                                                padding_side='left',
+                                                # model_max_length=1024
+                                                )
+    tokenizer.add_special_tokens({'pad_token': DEFINE_PAD_TOKEN})
+    model.pad_token_id = tokenizer.pad_token_id
+    model.pad_token = tokenizer.pad_token
+    model.config.pad_token_id = model.config.eos_token_id
+
+    return model, tokenizer
+
+
+def create_sft_datasets(datasets, tokenizer, format_func, seq_length=512):
+    return datasets, None
+
+def create_collator(tokenizer):
+    '''
+    ref https://github.com/huggingface/trl/blob/main/tests/test_data_collator_completion_only.py
+    '''
+    # instruction_template = "###Question: "
+    response_template = "###Answer:"
+    response_template_id = tokenizer.encode(
+            response_template, add_special_tokens=False
+        )[1:]
+    return DataCollatorForCompletionOnlyLM(response_template_id, tokenizer=tokenizer)
+
+
+def train():
+    model, tokenizer = create_model_tokenizer(model_name)
+    datasets, _ = create_datasets(dataset_name, dataset_sub_name)
+    format_fun = formatting_prompt_response_func_batched
+    train_datasets, _ = create_sft_datasets(datasets, tokenizer, format_fun, seq_length)
+    collator = create_collator(tokenizer)
+
+    # peft
+    peft_config = create_peft(is_peft)
+
+    training_args = SFTConfig(
+        output_dir=output_name,
+        save_strategy='epoch',
+        logging_steps=1,
+        num_train_epochs=num_train_epochs,
+        gradient_checkpointing=True,
+        bf16=True,
+        learning_rate=learning_rate,
+        warmup_ratio=0.1,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        gradient_accumulation_steps=gradient_accumulation_steps,
+        deepspeed=deepspeed_config_name,
+        report_to='wandb',
+        lr_scheduler_type='cosine',
+        max_seq_length=seq_length,
+        # max_steps=10,
+    )
+
+    trainer = SFTTrainer(
+        model,
+        args=training_args,
+        train_dataset=train_datasets,
+        peft_config=peft_config,
+        data_collator=collator,
+        formatting_func=format_fun,
+    )
+    trainer.train()
+    trainer.save_model(output_name)
+
+
+if __name__ == "__main__":
+    train()

utils.py

@@ -0,0 +1,322 @@
+import torch
+import re
+import random
+
+from transformers.utils import PaddingStrategy
+from accelerate import Accelerator
+from peft import LoraConfig, TaskType
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Any, List, Union
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    PreTrainedTokenizerBase,
+    HfArgumentParser,
+)
+
+# DEFINE_EOS_TOKEN = '''</s>'''
+# DEFINE_BOS_TOKEN = '''<s>'''
+# DEFINE_PAD_TOKEN = '''<pad>'''
+# SYSTEM_PROMPT = '''You are a robot named "MA-RLHF", you are always friendly and answer questions。'''
+DEFINE_BOS_TOKEN = '''<|begin_of_text|>'''
+DEFINE_EOS_TOKEN = '''<|end_of_text|>'''
+DEFINE_PAD_TOKEN = '''<|reserved_special_token_0|>'''
+SYSTEM_PROMPT = '''You are MA-RLHF Chatbot, you should friendly answer the question'''
+
+# o1
+DEFINE_SEP_TOKEN = '''<|reserved_special_token_1|>'''  # seperate token, or step token
+DEFINE_POSITIVE_TOKEN = '''Positive'''
+DEFINE_NEGATIVE_TOKEN= '''Negative'''
+STEP_INSTRUCTION = '''Solve this math problem using step-by-step reasoning. Require that the output of each step ends with the "<|reserved_special_token_1|>" token.\n'''
+PRM800K_STEP_INSTRUCTION = '''Solve this math problem using step-by-step reasoning. Require that the output of each step ends with the "<|reserved_special_token_1|>" token.\n'''
+MATH_STEP_INSTRUCTION = '''Solve this math problem using step-by-step reasoning. \n'''
+GSM8K_STEP_INSTRUCTION = '''Solve this math problem using step-by-step reasoning. Require that the output of each step ends with the "<|reserved_special_token_1|>" token.\n'''
+# PRM_INSTRUCTION = '''Scoring step-by-step reasoning with predict "Positive" or "Negative" .\n'''
+PRM_INSTRUCTION = '''Score each step under the 'Positive' and 'Negative' labels based on its correctness.\n'''
+
+
+def is_main_process():
+    return (
+        not torch.distributed.is_available()
+        or not torch.distributed.is_initialized()
+        or torch.distributed.get_rank() == 0
+    )
+
+
+def maybe_distributed_barrier():
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        torch.distributed.barrier()
+
+
+def create_model_tokenizer(name):
+    # QLoRA
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16
+    )
+
+    device_map = {"": Accelerator().local_process_index}
+    print('device map: ', device_map)
+
+    model = AutoModelForCausalLM.from_pretrained(
+        name,
+        quantization_config=bnb_config,
+        device_map=device_map,
+        # torch_dtype=torch.bfloat16,
+        # use_flash_attention_2=True # gpt 2 not support flash attention2
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(name, use_fast=True)
+
+    return model, tokenizer
+
+
+def create_peft(peft_flag: bool = False) -> LoraConfig:
+    if peft_flag == False:
+        return None
+    else:
+        # default peft lora is Q_Lora K_Lora
+        peft_config = LoraConfig(
+            r=64,
+            lora_alpha=8,
+            bias="none",
+            # lora_dropout=0.05,
+            task_type="CAUSAL_LM",
+        )
+        return peft_config
+
+
+def create_peft_lm_head(peft_flag: bool = False) -> LoraConfig:
+    '''
+    当新加入step token时，如果不对LM_head 加lora, 会导致难预测出step token
+    '''
+    if peft_flag == False:
+        return None
+    else:
+        # default peft lora is Q_Lora K_Lora
+        peft_config = LoraConfig(
+            r=64,
+            lora_alpha=8,
+            bias="none",
+            # lora_dropout=0.05,
+            task_type="CAUSAL_LM",
+            target_modules = ['q_proj', 'k_proj', 'v_proj', 'o_proj', 'lm_head'],
+        )
+        return peft_config
+
+def create_peft_prm_lm_head(peft_flag: bool = False) -> LoraConfig:
+    '''
+    当新加入step token时，如果不对LM_head 加lora, 会导致难预测出step token
+    '''
+    if peft_flag == False:
+        return None
+    else:
+        # default peft lora is Q_Lora K_Lora
+        peft_config = LoraConfig(
+            r=64,
+            lora_alpha=8,
+            bias="none",
+            lora_dropout=0,
+            task_type="CAUSAL_LM",
+            target_modules = ['q_proj', 'k_proj',  'lm_head'],
+        )
+        return peft_config
+
+def create_peft_reward_model(peft_flag: bool = False) -> LoraConfig:
+    if peft_flag == False:
+        return None
+    else:
+        # default peft lora is Q_Lora K_Lora
+        peft_config = LoraConfig(
+            task_type=TaskType.SEQ_CLS,
+            inference_mode=False,
+            r=32,
+            lora_alpha=8,
+            bias="none",
+            lora_dropout=0.05,
+            modules_to_save=["scores"],
+        )
+        return peft_config
+
+
+@dataclass
+class RewardDataCollatorWithPadding:
+    tokenizer: PreTrainedTokenizerBase
+    padding: Union[bool, str, PaddingStrategy] = True
+    max_length: Optional[int] = None
+    pad_to_multiple_of: Optional[int] = None
+    return_tensors: str = "pt"
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
+        features_j = []
+        features_k = []
+        for feature in features:
+            features_j.append(
+                {
+                    "input_ids": feature["input_ids_j"],
+                    "attention_mask": feature["attention_mask_j"],
+                }
+            )
+            features_k.append(
+                {
+                    "input_ids": feature["input_ids_k"],
+                    "attention_mask": feature["attention_mask_k"],
+                }
+            )
+        batch_j = self.tokenizer.pad(
+            features_j,
+            padding=self.padding,
+            max_length=self.max_length,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+            return_tensors=self.return_tensors,
+        )
+        batch_k = self.tokenizer.pad(
+            features_k,
+            padding=self.padding,
+            max_length=self.max_length,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+            return_tensors=self.return_tensors,
+        )
+        batch = {
+            "input_ids_j": batch_j["input_ids"],
+            "attention_mask_j": batch_j["attention_mask"],
+            "input_ids_k": batch_k["input_ids"],
+            "attention_mask_k": batch_k["attention_mask"],
+            "return_loss": True,
+        }
+        return batch
+
+
+@dataclass
+class ScriptArguments:
+    model_name: Optional[str] = field(default="", metadata={"help": "the model name"})
+
+    base_model_name: Optional[str] = field(default="", metadata={"help": "pretrained"})
+
+    reward_model_name: Optional[str] = field(default="", metadata={"help": "the reward model name"})
+
+    merged_model_name: Optional[str] = field(default="", metadata={"help": "lora + model"})
+
+    output_name: Optional[str] = field(default="", metadata={"help": "n steps to save the model"})
+
+    lora_path: Optional[str] = field(default="", metadata={"help": "lora path"})
+
+    dataset_name: Optional[str] = field(
+        default="", metadata={"help": "chinese medical english alpaca"}
+    )
+
+    dataset_sub_name: Optional[str] = field(default="", metadata={"help": "hf dataset config name"})
+
+    dataset_split: Optional[str] = field(default="train", metadata={"help": "dataset split"})
+
+    deepspeed_config_name: Optional[str] = field(default="", metadata={"help": "ds.json"})
+
+    prompt: Optional[str] = field(default="", metadata={"help": "for test generation"})
+
+    system_prompt: Optional[str] = field(default="", metadata={"help": "optional system prompt override"})
+
+    learning_rate: Optional[float] = field(
+        default=5e-6, metadata={"help": "todo: the learning rate,"}
+    )
+
+    seq_length: Optional[int] = field(default=1024, metadata={"help": "context max length"})
+
+    max_new_tokens: Optional[int] = field(default=128, metadata={"help": "max generate tokens"})
+
+    output_max_length: Optional[int] = field(
+        default=128, metadata={"help": "ppo maximum length for generation"}
+    )
+
+    mini_batch_size: Optional[int] = field(default=1, metadata={"help": "the PPO minibatch size"})
+
+    batch_size: Optional[int] = field(default=8, metadata={"help": "the batch size"})
+
+    ppo_epochs: Optional[int] = field(default=1, metadata={"help": "the number of ppo epochs"})
+
+    num_train_epochs:  Optional[int] = field(default=1, metadata={"help": "train epochs "})
+
+    gradient_accumulation_steps: Optional[int] = field(
+        default=1, metadata={"help": "gradient accumulation steps"}
+    )
+
+    early_stopping: Optional[bool] = field(
+        default=False, metadata={"help": "whether to early stop"}
+    )
+
+    target_kl: Optional[float] = field(
+        default=0.1, metadata={"help": "kl target for early stopping"}
+    )
+
+    seed: Optional[int] = field(default=0, metadata={"help": "the seed"})
+
+    use_QLora: Optional[bool] = field(default=False, metadata={"help": "todo optional"})
+
+    use_flash_attention_2: Optional[bool] = field(
+        default=False, metadata={"help": "gpt2 no flash attention2"}
+    )
+
+    merge_checkpoint_type: Optional[str] = field(default='LM', metadata={"help": "merge check point"})
+
+    use_qlora_double_quant: Optional[bool] = field(default=False, metadata={"help": "merge check point"})
+
+    step_generate: Optional[bool] = field(default=False, metadata={"help": "step generation"})
+
+
+
+def resolve_system_prompt(system_prompt: Optional[str] = None) -> str:
+    return system_prompt or SYSTEM_PROMPT
+
+
+def format_prompt_answer(question, answer, system_prompt: Optional[str] = None):
+    '''for generation'''
+    current_system_prompt = resolve_system_prompt(system_prompt)
+    return f"###System: {current_system_prompt}\n###Question: {question}\n###Answer: {answer} {DEFINE_EOS_TOKEN}"
+
+
+def format_prompt(question, system_prompt: Optional[str] = None):
+    current_system_prompt = resolve_system_prompt(system_prompt)
+    return f"###System: {current_system_prompt}\n###Question: {question}\n###Answer: "
+
+
+def formatting_prompt_response_func(example):
+    return format_prompt_answer(
+        example["prompt"],
+        example["response"],
+        system_prompt=example.get("system"),
+    )
+
+
+def formatting_prompt_response_func_batched(example):
+    output_text = []
+    systems = example.get("system", [None] * len(example["prompt"]))
+    for system_prompt, prompt, response in zip(systems, example["prompt"], example["response"]):
+        output_text.append(
+            format_prompt_answer(prompt, response, system_prompt=system_prompt)
+        )
+    return output_text
+
+
+# medical finetune data haven't 'input', only has 'instruction'
+def formatting_finetune_func(example):
+    return format_prompt_answer(example['instruction'], example['output'])
+
+
+def formatting_alpaca_func_bached(example):
+    output_text = []
+    for instruction, item_input, item_output in zip(example["instruction"], 
+                                        example['input'], 
+                                        example['output'] ):
+        text = format_prompt_answer(f"{instruction} {item_input}".strip(), item_output)
+        output_text.append(text)
+    return output_text
+
+
+def formatting_alpaca_func(example):
+    return format_prompt_answer(
+        f"{example['instruction']} {example['input']}".strip(),
+        example['output'],
+    )
+
+
+def formatting_alpaca_chinese_func(example):
+    return f"###System: {SYSTEM_PROMPT}\n###Question: {example['instruction_zh']} {example['input_zh']}\n###Answer: {example['output_zh']}{DEFINE_EOS_TOKEN}"